LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: manpat[P]iterator_trait/./iterator_trait/std_adaptor.h
// Function: InputIteratorAdaptor<int*, int*>::next()
Option<Item> next() {
		if (!m_begin || !m_end) return None;

		if (m_begin != m_end) {
			Option<Item> r(std::move(*m_begin));
			++m_begin;
			return r;
		}

		return None;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, (%rax)
je 0x4d87
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4d93
movq 0x8(%rsp), %rdi
callq 0x4f60
jmp 0x4de9
movq 0x18(%rsp), %rcx
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
je 0x4ddf
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
movq (%rax), %rsi
callq 0x4f90
movq 0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movb $0x1, 0x26(%rsp)
testb $0x1, 0x26(%rsp)
jne 0x4ddd
movq 0x8(%rsp), %rdi
callq 0x4a50
jmp 0x4de9
movq 0x8(%rsp), %rdi
callq 0x4f60
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: manpat[P]iterator_trait/./iterator_trait/option.h
// Function: Option<int, true>::Option<int, true>(Option<int, true>&&)
Option(Option<TT, C>&& o) : m_valid{o.m_valid} {
		if (m_valid)
			new (&m_value) T ( std::move(o.m_value) );

		o.m_valid = false;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rcx
movb 0x4(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x4(%rax)
testb $0x1, 0x4(%rax)
je 0x4e36
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rsp), %rax
movb $0x0, 0x4(%rax)
retq
// File: manpat[P]iterator_trait/./iterator_trait/std_adaptor.h
// Function: InputIteratorAdaptor<int*, int*>::InputIteratorAdaptor(InputIteratorAdaptor<int*, int*>&&)
InputIteratorAdaptor(InputIteratorAdaptor&& o)
		: m_begin{ o.m_begin }
		, m_end{ o.m_end } {

		o.m_begin = nullptr;
		o.m_end = nullptr;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rax
movq $0x0, (%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: manpat[P]iterator_trait/./iterator_trait/std_adaptor.h
// Function: InputIteratorAdaptor<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::InputIteratorAdaptor(InputIteratorAdaptor<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&)
InputIteratorAdaptor(InputIteratorAdaptor&& o) : m_valid{ o.m_valid } {
		if (m_valid) {
			new (&m_begin) StdBeginIt { std::forward<StdBeginIt>(o.m_begin) };
			new (&m_end) StdEndIt { std::forward<StdEndIt>(o.m_end) };
			o.m_valid = false;
		}
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rcx
movb 0x10(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x10(%rax)
testb $0x1, 0x10(%rax)
je 0x5fae
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rax
movb $0x0, 0x10(%rax)
retq
nop
// File: manpat[P]iterator_trait/./iterator_trait/std_adaptor.h
// Function: InputIteratorAdaptor<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::next()
Option<Item> next() {
		if (!m_valid) return None;

		if (m_begin != m_end) {
			Option<Item> r(std::move(*m_begin));
			++m_begin;
			return r;
		}

		return None;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x10(%rax)
jne 0x63f7
movq 0x8(%rsp), %rdi
callq 0x53f0
jmp 0x6456
movq 0x18(%rsp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
callq 0x6490
testb $0x1, %al
jne 0x640e
jmp 0x644c
movq 0x18(%rsp), %rdi
movb $0x0, 0x26(%rsp)
callq 0x64d0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x5420
movq 0x18(%rsp), %rdi
callq 0x64e0
movb $0x1, 0x26(%rsp)
testb $0x1, 0x26(%rsp)
jne 0x644a
movq 0x8(%rsp), %rdi
callq 0x4af0
jmp 0x6456
movq 0x8(%rsp), %rdi
callq 0x53f0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
// File: manpat[P]iterator_trait/./iterator_trait/iterator.h
// Function: IterZip<InputIteratorAdaptor<char const*, char const*>, InputIteratorAdaptor<char const*, char const*>>::next()
Option<Item> next() {
		auto a = m_iter.next();
		auto b = m_iter2.next();
		if (a && b) {
			return Some(Item(a.unwrap(), b.unwrap()));
		}

		return None;
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rsi
movq %rsi, 0x20(%rsp)
leaq 0x54(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x5a30
movq 0x28(%rsp), %rsi
leaq 0x56(%rsp), %rdi
callq 0x5ae0
jmp 0x6635
leaq 0x54(%rsp), %rdi
callq 0x5b20
movq 0x20(%rsp), %rsi
addq $0x10, %rsi
leaq 0x40(%rsp), %rdi
callq 0x5a30
jmp 0x6654
leaq 0x42(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5ae0
jmp 0x6665
leaq 0x40(%rsp), %rdi
callq 0x5b20
leaq 0x56(%rsp), %rdi
callq 0x5b40
testb $0x1, %al
jne 0x6682
jmp 0x6788
leaq 0x42(%rsp), %rdi
callq 0x5b40
testb $0x1, %al
jne 0x6695
jmp 0x6788
leaq 0x56(%rsp), %rdi
callq 0x5bd0
movb %al, 0xf(%rsp)
jmp 0x66a5
movb 0xf(%rsp), %al
movb %al, 0x3a(%rsp)
leaq 0x42(%rsp), %rdi
callq 0x5bd0
movb %al, 0xe(%rsp)
jmp 0x66bd
movb 0xe(%rsp), %al
movb %al, 0x39(%rsp)
leaq 0x3b(%rsp), %rdi
leaq 0x3a(%rsp), %rsi
leaq 0x39(%rsp), %rdx
callq 0x6920
jmp 0x66db
leaq 0x3d(%rsp), %rdi
leaq 0x3b(%rsp), %rsi
callq 0x68a0
jmp 0x66ec
movq 0x10(%rsp), %rdi
leaq 0x3d(%rsp), %rsi
callq 0x67e0
jmp 0x66fd
leaq 0x3d(%rsp), %rdi
callq 0x6830
movl $0x1, 0x34(%rsp)
jmp 0x679c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x54(%rsp), %rdi
callq 0x5b20
jmp 0x67ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x67c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5b20
jmp 0x67c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x67ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x3d(%rsp), %rdi
callq 0x6830
jmp 0x67ba
movq 0x10(%rsp), %rdi
callq 0x6950
jmp 0x6794
movl $0x1, 0x34(%rsp)
leaq 0x42(%rsp), %rdi
callq 0x5b20
leaq 0x56(%rsp), %rdi
callq 0x5b20
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
leaq 0x42(%rsp), %rdi
callq 0x5b20
leaq 0x56(%rsp), %rdi
callq 0x5b20
movq 0x48(%rsp), %rdi
callq 0x1140
nopl (%rax,%rax)
// File: manpat[P]iterator_trait/./iterator_trait/iterator.h
// Function: IterChain<InputIteratorAdaptor<char const*, char const*>, InputIteratorAdaptor<char const*, char const*>>::next()
Option<Item> next() {
		if(auto a = m_iter.next()) {
			return Some(Item(a.unwrap()));
		}

		if(auto b = m_iter2.next()) {
			return Some(Item(b.unwrap()));
		}

		return None;
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rsi
movq %rsi, 0x30(%rsp)
leaq 0x64(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x5a30
movq 0x38(%rsp), %rsi
leaq 0x66(%rsp), %rdi
callq 0x5ae0
jmp 0x6ac5
leaq 0x64(%rsp), %rdi
callq 0x5b20
leaq 0x66(%rsp), %rdi
callq 0x5b40
testb $0x1, %al
jne 0x6ae2
jmp 0x6b7d
leaq 0x66(%rsp), %rdi
callq 0x5bd0
movb %al, 0x1f(%rsp)
jmp 0x6af2
movb 0x1f(%rsp), %al
movb %al, 0x51(%rsp)
leaq 0x52(%rsp), %rdi
leaq 0x51(%rsp), %rsi
callq 0x6080
jmp 0x6b0b
movq 0x20(%rsp), %rdi
leaq 0x52(%rsp), %rsi
callq 0x5370
jmp 0x6b1c
leaq 0x52(%rsp), %rdi
callq 0x4af0
movl $0x1, 0x4c(%rsp)
jmp 0x6b85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x64(%rsp), %rdi
callq 0x5b20
jmp 0x6cc5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x6c32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x52(%rsp), %rdi
callq 0x4af0
jmp 0x6c32
movl $0x0, 0x4c(%rsp)
leaq 0x66(%rsp), %rdi
callq 0x5b20
movl 0x4c(%rsp), %eax
testl %eax, %eax
je 0x6b9e
jmp 0x6b99
jmp 0x6cbb
movq 0x30(%rsp), %rsi
addq $0x10, %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5a30
movq 0x10(%rsp), %rsi
leaq 0x4a(%rsp), %rdi
callq 0x5ae0
jmp 0x6bc7
leaq 0x48(%rsp), %rdi
callq 0x5b20
leaq 0x4a(%rsp), %rdi
callq 0x5b40
testb $0x1, %al
jne 0x6be4
jmp 0x6c85
leaq 0x4a(%rsp), %rdi
callq 0x5bd0
movb %al, 0xf(%rsp)
jmp 0x6bf4
movb 0xf(%rsp), %al
movb %al, 0x45(%rsp)
leaq 0x46(%rsp), %rdi
leaq 0x45(%rsp), %rsi
callq 0x6080
jmp 0x6c0d
movq 0x20(%rsp), %rdi
leaq 0x46(%rsp), %rsi
callq 0x5370
jmp 0x6c1e
leaq 0x46(%rsp), %rdi
callq 0x4af0
movl $0x1, 0x4c(%rsp)
jmp 0x6c8d
leaq 0x66(%rsp), %rdi
callq 0x5b20
jmp 0x6cc5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5b20
jmp 0x6cc5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x6caf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x46(%rsp), %rdi
callq 0x4af0
jmp 0x6caf
movl $0x0, 0x4c(%rsp)
leaq 0x4a(%rsp), %rdi
callq 0x5b20
movl 0x4c(%rsp), %eax
testl %eax, %eax
je 0x6ca3
jmp 0x6ca1
jmp 0x6cbb
movq 0x20(%rsp), %rdi
callq 0x53f0
jmp 0x6cbb
leaq 0x4a(%rsp), %rdi
callq 0x5b20
jmp 0x6cc5
movq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x1140
nop
// File: brianwu02[P]ImageProcessing/convolve.cpp
// Function: allocateKernel(int, int, int)
kernelP allocateKernel(int w, int h, int s) {
    float *p;
    kernelP k;

    k = (kernelP) malloc(sizeof(kernelS));
    p = (float *) malloc(w * h * s);
    if (p == NULL) {
        cerr << "allocateKernel error, Insufficient memory" << endl;
        return ((kernelP) NULL);
    }

    k->width = w;
    k->height = h;
    k->kernel = p;

    return k;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x10, %edi
callq 0x2280
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
movslq %eax, %rdi
callq 0x2280
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x31f9
movq 0x3e1c(%rip), %rdi      # 0x6ff0
leaq 0x1e4a(%rip), %rsi      # 0x5025
callq 0x21c0
movq %rax, %rdi
movq 0x3dd6(%rip), %rsi      # 0x6fc0
callq 0x21d0
movq $0x0, -0x8(%rbp)
jmp 0x3220
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: brianwu02[P]ImageProcessing/convolve.cpp
// Function: readKernelFile[abi:cxx11](char*)
std:: string readKernelFile(char *file) {
    std::string filename = file;
    std::string str;
    std::ifstream t(filename);

    t.seekg(0, std::ios::end);
    str.reserve(t.tellg());
    t.seekg(0, std::ios::beg);

    str.assign((std::istreambuf_iterator<char>(t)),
            std::istreambuf_iterator<char>());

    return str;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, -0x2a0(%rbp)
movq %rdi, %rax
movq %rax, -0x298(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x290(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x288(%rbp)
callq 0x23c0
movq -0x290(%rbp), %rsi
movq -0x288(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3540
jmp 0x3288
leaq -0x31(%rbp), %rdi
callq 0x21f0
movq -0x2a0(%rbp), %rdi
movb $0x0, -0x45(%rbp)
callq 0x22b0
leaq -0x250(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x8, %edx
callq 0x2350
jmp 0x32b8
xorl %eax, %eax
movl %eax, %esi
leaq -0x250(%rbp), %rdi
movl $0x2, %edx
callq 0x2290
jmp 0x32cf
leaq -0x250(%rbp), %rdi
callq 0x2390
movq %rdx, -0x2b0(%rbp)
movq %rax, -0x2a8(%rbp)
jmp 0x32eb
movq -0x2b0(%rbp), %rax
movq -0x2a8(%rbp), %rcx
movq %rcx, -0x260(%rbp)
movq %rax, -0x258(%rbp)
leaq -0x260(%rbp), %rdi
callq 0x35f0
movq %rax, -0x2b8(%rbp)
jmp 0x331c
movq -0x2b8(%rbp), %rsi
movq -0x2a0(%rbp), %rdi
callq 0x2330
jmp 0x3331
xorl %edx, %edx
movl %edx, %esi
leaq -0x250(%rbp), %rdi
callq 0x2290
jmp 0x3343
leaq -0x270(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x36c0
leaq -0x280(%rbp), %rdi
callq 0x3720
movq -0x2a0(%rbp), %rdi
movq -0x270(%rbp), %rsi
movl -0x268(%rbp), %edx
movq -0x280(%rbp), %rcx
movl -0x278(%rbp), %r8d
callq 0x3610
jmp 0x338b
movb $0x1, -0x45(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x2060
testb $0x1, -0x45(%rbp)
jne 0x33ee
jmp 0x33e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x21f0
jmp 0x341c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3407
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x2060
jmp 0x3407
movq -0x2a0(%rbp), %rdi
callq 0x2130
leaq -0x30(%rbp), %rdi
callq 0x2130
movq -0x298(%rbp), %rax
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbp
retq
movq -0x2a0(%rbp), %rdi
callq 0x2130
leaq -0x30(%rbp), %rdi
callq 0x2130
movq -0x40(%rbp), %rdi
callq 0x23b0
nopw %cs:(%rax,%rax)
// File: brianwu02[P]ImageProcessing/convolve.cpp
// Function: cfa(char)
int cfa(char str) {
    // dumb way to parse. convert ASCII char to INT.

    if (str == 48) { return 0; }
    else if (str == 49) { return 1; }
    else if (str == 50) { return 2; }
    else if (str == 51) { return 3; } 
    else if (str == 52) { return 4; }
    else if (str == 53) { return 5; }
    else if (str == 54) { return 6; }
    else if (str == 55) { return 7; }
    else if (str == 56) { return 8; }
    else if (str == 57) { return 9; }


    
    
    else {
        cerr << "error parsing" << endl;
        return str;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jne 0x3453
movl $0x0, -0x4(%rbp)
jmp 0x352a
movsbl -0x5(%rbp), %eax
cmpl $0x31, %eax
jne 0x3468
movl $0x1, -0x4(%rbp)
jmp 0x352a
movsbl -0x5(%rbp), %eax
cmpl $0x32, %eax
jne 0x347d
movl $0x2, -0x4(%rbp)
jmp 0x352a
movsbl -0x5(%rbp), %eax
cmpl $0x33, %eax
jne 0x3492
movl $0x3, -0x4(%rbp)
jmp 0x352a
movsbl -0x5(%rbp), %eax
cmpl $0x34, %eax
jne 0x34a7
movl $0x4, -0x4(%rbp)
jmp 0x352a
movsbl -0x5(%rbp), %eax
cmpl $0x35, %eax
jne 0x34b9
movl $0x5, -0x4(%rbp)
jmp 0x352a
movsbl -0x5(%rbp), %eax
cmpl $0x36, %eax
jne 0x34cb
movl $0x6, -0x4(%rbp)
jmp 0x352a
movsbl -0x5(%rbp), %eax
cmpl $0x37, %eax
jne 0x34dd
movl $0x7, -0x4(%rbp)
jmp 0x352a
movsbl -0x5(%rbp), %eax
cmpl $0x38, %eax
jne 0x34ef
movl $0x8, -0x4(%rbp)
jmp 0x352a
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jne 0x3501
movl $0x9, -0x4(%rbp)
jmp 0x352a
movq 0x3ae8(%rip), %rdi      # 0x6ff0
leaq 0x1b40(%rip), %rsi      # 0x504f
callq 0x21c0
movq %rax, %rdi
movq 0x3aa2(%rip), %rsi      # 0x6fc0
callq 0x21d0
movsbl -0x5(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dacunni[P]stlloader/stldump.cpp
// Function: main
int main(int argc, char ** argv)
{
    if(argc < 2) {
        std::cerr << "Please supply an argument\n";
        return EXIT_FAILURE;
    }
    stlloader::Mesh mesh;
    stlloader::parse_file(argv[1], mesh);
    stlloader::print(mesh);

    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x4edb
movq 0x5122(%rip), %rdi      # 0x9fe8
leaq 0x21f8(%rip), %rsi      # 0x70c5
callq 0x3270
movl $0x1, -0x4(%rbp)
jmp 0x4f2f
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x5400
movq -0x80(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x44d0
jmp 0x4efb
leaq -0x68(%rbp), %rdi
callq 0x3720
jmp 0x4f06
movl $0x0, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5440
jmp 0x4f2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5440
jmp 0x4f3b
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
nop
// File: temelmertcan[P]multgen/src/multgen.cpp
// Function: convertToString[abi:cxx11](char*, int)
string convertToString(char* a, int size)
{
  int i;
  string s = "";
  for (i = 0; i < size; i++) {
    s = s + a[i];
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3430
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x547b3(%rip), %rsi     # 0x595e1
callq 0x3320
jmp 0x4e35
leaq -0x1a(%rbp), %rdi
callq 0x32a0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4eb7
movq -0x60(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edx
leaq -0x50(%rbp), %rdi
callq 0x1e3f0
jmp 0x4e68
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x32b0
leaq -0x50(%rbp), %rdi
callq 0x31a0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4e45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x32a0
jmp 0x4ed4
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31a0
jmp 0x4ed4
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x4eca
movq -0x60(%rbp), %rdi
callq 0x31a0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: temelmertcan[P]multgen/src/multgen.cpp
// Function: print_int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::list<int, std::allocator<int>> const&)
void print_int(string x, std::list<int> const &list)
{
  cout << x << " ";
  for (auto const &i: list) {
    std::cout << i << " ";
  }
  cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq 0x5966b(%rip), %rdi     # 0x65fc8
callq 0x3210
movq %rax, %rdi
leaq 0x4a2ab(%rip), %rsi     # 0x56c17
callq 0x3250
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ea20
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ea50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1ea80
testb $0x1, %al
jne 0xc9a6
jmp 0xc9df
leaq -0x20(%rbp), %rdi
callq 0x1eab0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %esi
movq 0x59608(%rip), %rdi     # 0x65fc8
callq 0x3410
movq %rax, %rdi
leaq 0x4a248(%rip), %rsi     # 0x56c17
callq 0x3250
leaq -0x20(%rbp), %rdi
callq 0x1eae0
jmp 0xc993
movq 0x595e2(%rip), %rdi     # 0x65fc8
movq 0x595cb(%rip), %rsi     # 0x65fb8
callq 0x3280
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: temelmertcan[P]multgen/src/multgen.cpp
// Function: write_to_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::deque<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>>>>>&)
void write_to_file (string file_name,
                    queue<string>& verilog){

  ofstream myfile;

  myfile.open (file_name);

  int indent_count = 0;

  while(!verilog.empty()) {
    string line = verilog.front();
    if (line.compare("indent") == 0)
      indent_count++;
    else if (line.compare("outdent") == 0)
      indent_count--;
    else {
      for (int i = 0; i<indent_count; i++)
        myfile << "    ";
      myfile << line << endl;
    }
    verilog.pop();
  }

  myfile.close();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x250(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x33f0
movq -0x258(%rbp), %rdi
movq -0x250(%rbp), %rsi
movl $0x10, %edx
callq 0x3130
jmp 0x1d597
movl $0x0, -0x220(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ecb0
movb %al, -0x259(%rbp)
jmp 0x1d5b2
movb -0x259(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1d5c3
jmp 0x1d70a
movq -0x10(%rbp), %rdi
callq 0x1ecd0
movq %rax, -0x268(%rbp)
jmp 0x1d5d5
movq -0x268(%rbp), %rsi
leaq -0x240(%rbp), %rdi
callq 0x3100
jmp 0x1d5ea
leaq -0x240(%rbp), %rdi
leaq 0x3a6c3(%rip), %rsi     # 0x57cbb
callq 0x30b0
cmpl $0x0, %eax
jne 0x1d62d
movl -0x220(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x220(%rbp)
jmp 0x1d6ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x1d72d
leaq -0x240(%rbp), %rdi
leaq 0x3a6f6(%rip), %rsi     # 0x57d31
callq 0x30b0
cmpl $0x0, %eax
jne 0x1d659
movl -0x220(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x220(%rbp)
jmp 0x1d6ec
movl $0x0, -0x244(%rbp)
movl -0x244(%rbp), %eax
cmpl -0x220(%rbp), %eax
jge 0x1d6b9
leaq 0x3af5e(%rip), %rsi     # 0x585d6
leaq -0x210(%rbp), %rdi
callq 0x3250
jmp 0x1d686
jmp 0x1d688
movl -0x244(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x244(%rbp)
jmp 0x1d663
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x31a0
jmp 0x1d72d
leaq -0x210(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x3210
movq %rax, -0x270(%rbp)
jmp 0x1d6d5
movq -0x270(%rbp), %rdi
movq 0x488d5(%rip), %rsi     # 0x65fb8
callq 0x3280
jmp 0x1d6ea
jmp 0x1d6ec
jmp 0x1d6ee
movq -0x10(%rbp), %rdi
callq 0x1ecf0
jmp 0x1d6f9
leaq -0x240(%rbp), %rdi
callq 0x31a0
jmp 0x1d5a1
leaq -0x210(%rbp), %rdi
callq 0x3350
jmp 0x1d718
leaq -0x210(%rbp), %rdi
callq 0x3380
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x3380
movq -0x218(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: temelmertcan[P]multgen/src/dadda.cpp
// Function: get_dadda_coeffs(int, int*&, int&)
void get_dadda_coeffs (int max, int *& coeffs, int& size){

  size = 0;
  for (int i = 2; i<max; i = int(i*1.5)){
    size++;
  }

  coeffs = new int[size];

  int cnt = 0;
  for (int i = 2; i<max; i = int(i*1.5)){
    coeffs[size - ++cnt] = i;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x2, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x46e31
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
cvtsi2sdl -0x1c(%rbp), %xmm0
movsd 0x127b4(%rip), %xmm1    # 0x595d8
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
jmp 0x46e04
movq -0x18(%rbp), %rax
movslq (%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x20(%rbp)
movl $0x2, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x46eb4
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl -0x20(%rbp), %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
subl %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
cvtsi2sdl -0x24(%rbp), %xmm0
movsd 0x12731(%rip), %xmm1    # 0x595d8
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x24(%rbp)
jmp 0x46e71
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: temelmertcan[P]multgen/src/dadda.cpp
// Function: print_queue(std::queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::deque<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>>>>>*, int)
void print_queue (std::queue<string>* q,
		  int size){
  
  for (int i = 0; i<size; i++){

    std::queue<string> temp;

    while (!q[i].empty()){
      cout << q[i].front() << "\t";
      temp.push(q[i].front());
      q[i].pop();
    }

    q[i] = temp;
    cout << endl;
  }

  cout << endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x47012
leaq -0x60(%rbp), %rdi
callq 0x1ed10
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x1ecb0
movb %al, -0x6d(%rbp)
jmp 0x46f0b
movb -0x6d(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x46f19
jmp 0x46fc8
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x1ecd0
movq %rax, -0x78(%rbp)
jmp 0x46f37
movq -0x78(%rbp), %rsi
movq 0x1f086(%rip), %rdi     # 0x65fc8
callq 0x3210
movq %rax, -0x80(%rbp)
jmp 0x46f4d
movq -0x80(%rbp), %rdi
leaq 0x12688(%rip), %rsi     # 0x595e0
callq 0x3250
jmp 0x46f5f
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x1ecd0
movq %rax, -0x88(%rbp)
jmp 0x46f80
movq -0x88(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x2e150
jmp 0x46f92
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x1ecf0
jmp 0x46fac
jmp 0x46eee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1edc0
jmp 0x4702e
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %rdi
leaq -0x60(%rbp), %rsi
callq 0x48790
jmp 0x46fe6
movq 0x1efdb(%rip), %rdi     # 0x65fc8
movq 0x1efc4(%rip), %rsi     # 0x65fb8
callq 0x3280
jmp 0x46ffb
leaq -0x60(%rbp), %rdi
callq 0x1edc0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x46ed9
movq 0x1efaf(%rip), %rdi     # 0x65fc8
movq 0x1ef98(%rip), %rsi     # 0x65fb8
callq 0x3280
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3420
nopw (%rax,%rax)
// File: temelmertcan[P]multgen/src/wallace.cpp
// Function: move_to_main_queue(std::queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::deque<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::queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::deque<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>>>>>*, int)
void move_to_main_queue (queue<string>* temp,
                         queue<string>* main,
                         int size){
  for (int i = 0; i < size; i++){
    while(!temp[i].empty()){
      string cur = temp[i].front();
      temp[i].pop();
      main[i].push (cur);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4c3e8
jmp 0x4c338
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
callq 0x1ecb0
xorb $-0x1, %al
testb $0x1, %al
jne 0x4c357
jmp 0x4c3d8
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x1ecd0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x3100
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x1ecf0
jmp 0x4c395
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0x2e150
jmp 0x4c3b3
leaq -0x38(%rbp), %rdi
callq 0x31a0
jmp 0x4c338
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31a0
jmp 0x4c3ee
jmp 0x4c3da
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4c32a
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3420
nopw (%rax,%rax)
// File: temelmertcan[P]multgen/src/wallace.cpp
// Function: print_main_queue(std::queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::deque<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>>>>>*, int)
void print_main_queue (queue<string>* main,
		       int size){
  
  cout << "Printing main queue " << endl; 
  for (int i = 0; i < size; i++){
    cout << "Col " << i << ": ";
    queue<string> copyq = main[i];
    while (!copyq.empty()){
      cout << copyq.front() << " ";
      copyq.pop();
    }
    cout << endl;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x19baf(%rip), %rdi     # 0x65fc8
leaq 0xd24a(%rip), %rsi      # 0x5966a
callq 0x3250
movq %rax, %rdi
movq 0x19b89(%rip), %rsi     # 0x65fb8
callq 0x3280
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4c52c
movq 0x19b7a(%rip), %rdi     # 0x65fc8
leaq 0xd22a(%rip), %rsi      # 0x5967f
callq 0x3250
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x3410
movq %rax, %rdi
leaq 0xcd5c(%rip), %rsi      # 0x591cb
callq 0x3250
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x55730
leaq -0x60(%rbp), %rdi
callq 0x1ecb0
movb %al, -0x6d(%rbp)
jmp 0x4c49a
movb -0x6d(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4c4a5
jmp 0x4c500
leaq -0x60(%rbp), %rdi
callq 0x1ecd0
movq %rax, -0x78(%rbp)
jmp 0x4c4b4
movq -0x78(%rbp), %rsi
movq 0x19b09(%rip), %rdi     # 0x65fc8
callq 0x3210
movq %rax, -0x80(%rbp)
jmp 0x4c4ca
movq -0x80(%rbp), %rdi
leaq 0xa742(%rip), %rsi      # 0x56c17
callq 0x3250
jmp 0x4c4dc
leaq -0x60(%rbp), %rdi
callq 0x1ecf0
jmp 0x4c4e7
jmp 0x4c48c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1edc0
jmp 0x4c535
movq 0x19ac1(%rip), %rdi     # 0x65fc8
movq 0x19aaa(%rip), %rsi     # 0x65fb8
callq 0x3280
jmp 0x4c515
leaq -0x60(%rbp), %rdi
callq 0x1edc0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4c43b
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3420
nop
// File: temelmertcan[P]multgen/src/wallace.cpp
// Function: get_max_queue_size(std::queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::deque<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>>>>>*, int)
int get_max_queue_size (std::queue<string>* q, int size){

  int max=0;
  for (int i = 0; i < size; i++){
    int cur = q[i].size();
    if (max<cur)
      max = cur;
  }

  //cout << "!!! max queue size :"  <<max << endl;
  
  return max;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4c597
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
imulq $0x50, %rax, %rax
addq %rax, %rdi
callq 0x487c0
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4c58a
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x4c58c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4c55d
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: temelmertcan[P]multgen/src/wallace.cpp
// Function: create_4to2tree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>**, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int, int, bool, bool, std::queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::deque<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>>>>>&, int&, bool**&)::four2twoi::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void add(string var1,string var2,string var3,string var4){
      in1[size] = var1;
      in2[size] = var2;
      in3[size] = var3;
      in4[size] = var4;
      size++;
      
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x48(%rbp)
movq %rcx, -0x40(%rbp)
movq %r8, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x28(%rax), %rdi
movslq 0x4(%rax), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3050
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rdi
movslq 0x4(%rax), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3050
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rdi
movslq 0x4(%rax), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3050
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rdi
movslq 0x4(%rax), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x3050
movq -0x30(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mattcha[P]sgd-svm/sgd_svm_predict.cpp
// Function: load_model(char const*, Weight&)
int load_model(const char* modelname, Weight &weight)
{
    if (modelname == NULL) {
        fprintf(stderr, "modelname is null\n");
        return -1;
    }

    double lambda = 0.0;
    uint32_t iteration = 0;
    uint32_t w_size = 0;

    ifstream fin;
    fin.open(modelname);
    fin >> lambda >> iteration >> w_size;
    for (uint32_t wi=0; wi<w_size; ++wi) {
        weight.w_vec.push_back(0.0);
    }

    uint32_t idx = 0;
    double val = 0.0;
    while (fin) {
        fin >> idx >> val;
        weight.w_vec[idx] = val;
    }
    
    fprintf(stderr, "load model succ\n");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x24be
movq 0x5b37(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
leaq 0x2b59(%rip), %rsi      # 0x5004
movb $0x0, %al
callq 0x2240
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2679
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
leaq -0x230(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x21d0
movq -0x260(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x20e0
jmp 0x24fe
leaq -0x230(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2140
movq %rax, -0x268(%rbp)
jmp 0x2517
movq -0x268(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x2040
movq %rax, -0x270(%rbp)
jmp 0x2530
movq -0x270(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2040
jmp 0x2542
movl $0x0, -0x240(%rbp)
movl -0x240(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x25aa
movq -0x18(%rbp), %rdi
movq $0x0, -0x248(%rbp)
leaq -0x248(%rbp), %rsi
callq 0x2ba0
jmp 0x2574
jmp 0x2576
movl -0x240(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x240(%rbp)
jmp 0x254c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x2060
jmp 0x2685
movl $0x0, -0x24c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x258(%rbp)
movq -0x230(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x230(%rbp,%rax), %rdi
callq 0x2210
movb %al, -0x271(%rbp)
jmp 0x25df
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x25eb
jmp 0x264e
leaq -0x230(%rbp), %rdi
leaq -0x24c(%rbp), %rsi
callq 0x2040
movq %rax, -0x280(%rbp)
jmp 0x2607
movq -0x280(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x2140
jmp 0x261c
movsd -0x258(%rbp), %xmm0
movsd %xmm0, -0x288(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24c(%rbp), %eax
movl %eax, %esi
callq 0x2bd0
movsd -0x288(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x25bf
movq 0x5983(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
leaq 0x29b8(%rip), %rsi      # 0x5017
movb $0x0, %al
callq 0x2240
movl $0x0, -0x4(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x2060
movl -0x4(%rbp), %eax
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x238(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: mattcha[P]sgd-svm/sgd_svm_predict.cpp
// Function: main
int main(int argc, char** argv) 
{
    int ret;
    if (argc != 3) {
        fprintf(stderr, "Usage : %s modelname testfile\n", argv[0]);
        return 1;
    }

    char *modelname = argv[1];
    char *testfile = argv[2];

    Weight weight;
    ret = load_model(modelname, weight);
    if (ret != 0) {
        fprintf(stderr, "load model [%s] fail\n", modelname);
        return -1;
    }

    ret = predict(testfile, weight);
    if (ret != 0) {
        fprintf(stderr, "predict [%s] fail\n", testfile);
        return -1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x2aa7
movq 0x5555(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x2625(%rip), %rsi      # 0x50b9
movb $0x0, %al
callq 0x2240
movl $0x1, -0x4(%rbp)
jmp 0x2b8e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2c30
movq -0x60(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x2480
movl %eax, -0x54(%rbp)
jmp 0x2ade
movl -0x54(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2b2d
movq 0x54e7(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x25d9(%rip), %rsi      # 0x50d8
movb $0x0, %al
callq 0x2240
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x50(%rbp)
jmp 0x2b85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2c50
jmp 0x2b97
movq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x26a0
movl %eax, -0x64(%rbp)
jmp 0x2b3f
movl -0x64(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2b77
movq 0x5486(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x258e(%rip), %rsi      # 0x50ee
movb $0x0, %al
callq 0x2240
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x50(%rbp)
jmp 0x2b85
movl $0x0, -0x4(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2c50
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22b0
// File: czmccrory[P]ManchesterBaby/baby.cpp
// Function: ManchesterBaby::ldn(int)
void ManchesterBaby::ldn(int operand){

	presentMnemonic = "LDN " + to_string(operand);
  //Get the value at the store
  int negativeValue = store.at(operand).getDecVector();
  //make it negative
  negativeValue = -negativeValue;
  //Add set the accumulator to the negative operand
  accumulator.setDecVector(negativeValue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0xc(%rbp), %esi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5bf0
movq -0x68(%rbp), %rdx
leaq 0x75f2(%rip), %rsi      # 0xb084
leaq -0x30(%rbp), %rdi
callq 0x5ba0
jmp 0x3a9d
movq -0x70(%rbp), %rdi
addq $0x38, %rdi
leaq -0x30(%rbp), %rsi
callq 0x32d0
leaq -0x30(%rbp), %rdi
callq 0x3150
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x70(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x5b60
movq %rax, %rdi
callq 0x7f70
movq -0x70(%rbp), %rdi
movl %eax, -0x60(%rbp)
xorl %eax, %eax
subl -0x60(%rbp), %eax
movl %eax, -0x60(%rbp)
addq $0x28, %rdi
movl -0x60(%rbp), %esi
callq 0x7fe0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x58(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: czmccrory[P]ManchesterBaby/baby.cpp
// Function: ManchesterBaby::sub(int)
void ManchesterBaby::sub(int operand){

	presentMnemonic = "SUB " + to_string(operand);
 
  //Get the accumulator value
  int accumulatorDec = accumulator.getDecVector();

  //Get the Store value
  int storeDec = store.at(operand).getDecVector(); 

  int result = accumulatorDec- storeDec;

  accumulator.setDecVector(result);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %esi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5bf0
movq -0x70(%rbp), %rdx
leaq 0x7357(%rip), %rsi      # 0xb09c
leaq -0x30(%rbp), %rdi
callq 0x5ba0
jmp 0x3d50
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
leaq -0x30(%rbp), %rsi
callq 0x32d0
leaq -0x30(%rbp), %rdi
callq 0x3150
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x78(%rbp), %rdi
addq $0x28, %rdi
callq 0x7f70
movq -0x78(%rbp), %rdi
movl %eax, -0x60(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x5b60
movq %rax, %rdi
callq 0x7f70
movq -0x78(%rbp), %rdi
movl %eax, -0x64(%rbp)
movl -0x60(%rbp), %eax
subl -0x64(%rbp), %eax
movl %eax, -0x68(%rbp)
addq $0x28, %rdi
movl -0x68(%rbp), %esi
callq 0x7fe0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x58(%rbp), %rdi
callq 0x33e0
nopl (%rax,%rax)
// File: czmccrory[P]ManchesterBaby/baby.cpp
// Function: ManchesterBaby::imsub(int)
void ManchesterBaby::imsub(int operand){

	presentMnemonic = "IMSUB " + to_string(operand);

  //Get the accumulator value
  int accumulatorDec = accumulator.getDecVector();

  int result = accumulatorDec - operand;
  accumulator.setDecVector(result);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %esi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5bf0
movq -0x70(%rbp), %rdx
leaq 0x71e5(%rip), %rsi      # 0xb09a
leaq -0x30(%rbp), %rdi
callq 0x5ba0
jmp 0x3ec0
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
leaq -0x30(%rbp), %rsi
callq 0x32d0
leaq -0x30(%rbp), %rdi
callq 0x3150
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x78(%rbp), %rdi
addq $0x28, %rdi
callq 0x7f70
movq -0x78(%rbp), %rdi
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x64(%rbp)
addq $0x28, %rdi
movl -0x64(%rbp), %esi
callq 0x7fe0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x58(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: czmccrory[P]ManchesterBaby/baby.cpp
// Function: ManchesterBaby::cmp()
void ManchesterBaby::cmp(){

	presentMnemonic = "CMP ";
  int accumulatorValue = accumulator.getDecVector();
  //increment the CI if the
  if(accumulatorValue<0){
    incrementCI();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x38, %rdi
leaq 0x7142(%rip), %rsi      # 0xb0a1
callq 0x3310
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x7f70
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x3f83
movq -0x18(%rbp), %rdi
callq 0x3770
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: czmccrory[P]ManchesterBaby/baby.cpp
// Function: ManchesterBaby::mul(int)
void ManchesterBaby::mul(int operand) {

	presentMnemonic = "MUL " + to_string(operand);
	int accumulatorDec = accumulator.getDecVector(); 
	int storeDec = store.at(operand).getDecVector();
  //multiply the acumulator value with the value we got from the store
	int result = accumulatorDec * storeDec;
	accumulator.setDecVector(result);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %esi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5bf0
movq -0x70(%rbp), %rdx
leaq 0x70a8(%rip), %rsi      # 0xb0ad
leaq -0x30(%rbp), %rdi
callq 0x5ba0
jmp 0x4010
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
leaq -0x30(%rbp), %rsi
callq 0x32d0
leaq -0x30(%rbp), %rdi
callq 0x3150
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x78(%rbp), %rdi
addq $0x28, %rdi
callq 0x7f70
movq -0x78(%rbp), %rdi
movl %eax, -0x60(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x5b60
movq %rax, %rdi
callq 0x7f70
movq -0x78(%rbp), %rdi
movl %eax, -0x64(%rbp)
movl -0x60(%rbp), %eax
imull -0x64(%rbp), %eax
movl %eax, -0x68(%rbp)
addq $0x28, %rdi
movl -0x68(%rbp), %esi
callq 0x7fe0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x58(%rbp), %rdi
callq 0x33e0
nopl (%rax)
// File: czmccrory[P]ManchesterBaby/baby.cpp
// Function: ManchesterBaby::immul(int)
void ManchesterBaby::immul(int operand) {

	presentMnemonic = "IMMUL " + to_string(operand);
	int accumulatorDec = accumulator.getDecVector();
  //multiply the accumulator value and the operand
  int result = accumulatorDec * operand;
  accumulator.setDecVector(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %esi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5bf0
movq -0x70(%rbp), %rdx
leaq 0x6fd6(%rip), %rsi      # 0xb0ab
leaq -0x30(%rbp), %rdi
callq 0x5ba0
jmp 0x40e0
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
leaq -0x30(%rbp), %rsi
callq 0x32d0
leaq -0x30(%rbp), %rdi
callq 0x3150
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x78(%rbp), %rdi
addq $0x28, %rdi
callq 0x7f70
movq -0x78(%rbp), %rdi
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
imull -0xc(%rbp), %eax
movl %eax, -0x64(%rbp)
addq $0x28, %rdi
movl -0x64(%rbp), %esi
callq 0x7fe0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x58(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: czmccrory[P]ManchesterBaby/baby.cpp
// Function: ManchesterBaby::ldp(int)
void ManchesterBaby::ldp(int operand){
	presentMnemonic = "LDP " + to_string(operand);

	int storeValue = store.at(operand).getDecVector();
	//Add set the accumulator to the negative operand
 	accumulator.setDecVector(storeValue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0xc(%rbp), %esi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5bf0
movq -0x68(%rbp), %rdx
leaq 0x6f22(%rip), %rsi      # 0xb0b4
leaq -0x30(%rbp), %rdi
callq 0x5ba0
jmp 0x419d
movq -0x70(%rbp), %rdi
addq $0x38, %rdi
leaq -0x30(%rbp), %rsi
callq 0x32d0
leaq -0x30(%rbp), %rdi
callq 0x3150
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x70(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x5b60
movq %rax, %rdi
callq 0x7f70
movq -0x70(%rbp), %rdi
movl %eax, -0x60(%rbp)
addq $0x28, %rdi
movl -0x60(%rbp), %esi
callq 0x7fe0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x58(%rbp), %rdi
callq 0x33e0
nopl (%rax)