LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/std/valarray.hxx
// Function: cxon::cbor::imp::valarray_container_<unsigned char>::grow(unsigned long)
void grow(std::size_t n) {
                        CXON_ASSERT(n > a_.size(), "unexpected");
                        std::valarray<T> a(n);
#                           ifdef _MSC_VER // std::begin/std::end broken for empty std::valarray
                                for (std::size_t i = 0, is = a_.size(); i != is; ++i)
                                    a[i] = a_[i];
#                           else
                                std::copy(std::begin(a_), std::end(a_), std::begin(a));
#                           endif
                        a_.swap(a);
                    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rdi
callq 0x229260
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2293b0
movq -0x50(%rbp), %rax
movq (%rax), %rdi
callq 0x229440
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq (%rax), %rdi
callq 0x2294a0
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x229440
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x229400
jmp 0x22936f
movq -0x50(%rbp), %rax
movq (%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2294f0
leaq -0x20(%rbp), %rdi
callq 0x2287a0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2287a0
movq -0x28(%rbp), %rdi
callq 0x7690
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/cbor/lib/std/memory.hxx
// Function: bool cxon::read<cxon::CBOR<cxon::cbor::format_traits>, std::shared_ptr<int>, void>::value<unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>, cxon::CBOR<cxon::cbor::format_traits>>(std::shared_ptr<int>&, unsigned char const*&, unsigned char const*, cxon::context<cxon::CBOR<cxon::cbor::format_traits>>&)
static bool value(std::shared_ptr<T>& t, II& i, II e, Cx& cx) {
                    auto al = alc::make_context_allocator<T>(cx);
                        T* p;
#                   if __cplusplus < 201402L
                        return read_value<Y>(p, i, e, cx) && (t.reset(p, [al](T* p) mutable { al.release(p); }), true);
#                   else
                        return read_value<Y>(p, i, e, cx) && (t.reset(p, [al = std::move(al)](T* p) mutable { al.release(p); }), true);
#                   endif
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x29(%rbp), %rdi
callq 0x185330
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movb $0x0, -0x46(%rbp)
movb $0x0, -0x47(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x184eb0
movb %al, -0x48(%rbp)
jmp 0x233f47
movb -0x48(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x49(%rbp)
jne 0x233f56
jmp 0x233f99
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x45(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x29(%rbp), %rsi
callq 0x1855c0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movb $0x1, -0x46(%rbp)
movb $0x1, -0x47(%rbp)
callq 0x234010
jmp 0x233f92
movb $0x1, %al
movb %al, -0x49(%rbp)
jmp 0x233f99
movb -0x49(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
testb $0x1, -0x47(%rbp)
jne 0x233fa9
jmp 0x233fb2
leaq -0x45(%rbp), %rdi
callq 0x2340b0
leaq -0x29(%rbp), %rdi
callq 0x185490
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x233ff3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
testb $0x1, -0x47(%rbp)
jne 0x233fe8
jmp 0x233ff1
leaq -0x45(%rbp), %rdi
callq 0x2340b0
jmp 0x233ff3
leaq -0x29(%rbp), %rdi
callq 0x185490
movq -0x40(%rbp), %rdi
callq 0x7690
nopw %cs:(%rax,%rax)
nop
// File: willprice[P]parallel-cpp-workshop/parallel_for.cpp
// Function: main
int main(int argc, char **argv)
{
    std::mutex m;

    auto values = std::vector<double>(10000);

    tbb::parallel_for(tbb::blocked_range<int>(0, values.size()),
      [&](tbb::blocked_range<int> r){
          m.lock();
          std::cout << "Range size " << (r.end() - r.begin())
                    << " from " << r.begin() << " to " << r.end() << std::endl;
          m.unlock();

          for (int i = r.begin(); i < r.end(); i++) {
              values[i] = std::sin(i * 0.001);
          };
    });

    double total = 0;

    for (auto value : values)
    {
        total += value;
    }

    std::cout << total << std::endl;

    return 0;
}

// Assembly:
subq $0xc8, %rsp
movl $0x0, 0xc4(%rsp)
movl %edi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x3530
leaq 0x77(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3540
movq 0x10(%rsp), %rdx
leaq 0x78(%rsp), %rdi
movl $0x2710, %esi           # imm = 0x2710
callq 0x3550
jmp 0x23a3
leaq 0x77(%rsp), %rdi
callq 0x35d0
leaq 0x78(%rsp), %rdi
callq 0x35e0
movl %eax, %edx
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
movl $0x1, %ecx
callq 0x3600
jmp 0x23cc
leaq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x78(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2500
jmp 0x23f4
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
leaq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3630
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3660
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3690
testb $0x1, %al
jne 0x243a
jmp 0x24a0
leaq 0x28(%rsp), %rdi
callq 0x36d0
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x36e0
jmp 0x2425
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x77(%rsp), %rdi
callq 0x35d0
jmp 0x24f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x3700
jmp 0x24f0
movsd 0x38(%rsp), %xmm0
movq 0x6b2b(%rip), %rdi      # 0x8fd8
callq 0x2200
movq %rax, 0x8(%rsp)
jmp 0x24b9
movq 0x8(%rsp), %rdi
movq 0x6b03(%rip), %rsi      # 0x8fc8
callq 0x2140
jmp 0x24cc
movl $0x0, 0xc4(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x3700
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x21c0
nopw (%rax,%rax)
// File: lagoproject[P]arti/analysis/analysis.cc
// Function: Open(char*)
int Open(char *nfi) {
  char tmpc[256];
  if (strncmp(nfi+strlen(nfi)-4,".bz2",4)==0) {
    if (iverbose)
      fprintf(stderr,"File '%s' ending by bz2, reading it via bzip2\n",nfi);
    snprintf(tmpc,256,"bzip2 -d -c %s",nfi);
    fi=popen(tmpc,"r");
  }
  else if((fi=fopen(nfi,"r")) == NULL) {
    if (iverbose)
      fprintf(stderr,"Can't open file '%s' - Switching to SDTIN\n",nfi);
    fi=stdin;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq -0x118(%rbp), %rdi
addq %rax, %rdi
addq $-0x4, %rdi
leaq 0x238f(%rip), %rsi      # 0x36a7
movl $0x4, %edx
callq 0x1070
cmpl $0x0, %eax
jne 0x1386
cmpl $0x0, 0x6936(%rip)      # 0x7c64
je 0x134c
movq 0x3c99(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1dcb(%rip), %rsi      # 0x3110
movb $0x0, %al
callq 0x1130
leaq -0x110(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq 0x1ddc(%rip), %rdx      # 0x313f
movb $0x0, %al
callq 0x1160
leaq -0x110(%rbp), %rdi
leaq 0x262e(%rip), %rsi      # 0x39a6
callq 0x1050
movq %rax, 0x3db4(%rip)      # 0x5138
jmp 0x13db
movq -0x8(%rbp), %rdi
leaq 0x2615(%rip), %rsi      # 0x39a6
callq 0x10e0
movq %rax, 0x3d9b(%rip)      # 0x5138
cmpq $0x0, %rax
jne 0x13d9
cmpl $0x0, 0x68ba(%rip)      # 0x7c64
je 0x13c8
movq 0x3c1d(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1d8d(%rip), %rsi      # 0x314e
movb $0x0, %al
callq 0x1130
movq 0x3bf1(%rip), %rax      # 0x4fc0
movq (%rax), %rax
movq %rax, 0x3d5f(%rip)      # 0x5138
jmp 0x13db
movl $0x1, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax)
// File: lagoproject[P]arti/analysis/analysis.cc
// Function: curved(double, double)
void curved(double xp, double yp) {
	double d = r_earth + h;
	double t = sqrt(xp*xp + yp*yp)/d;
	double f = atan2(yp,xp);
	z = (d*cos(t) - r_earth)*cm2m;
	d *= sin(t);
	x = d*cos(f)*cm2m;
	y = d*sin(f)*cm2m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd 0x3a26(%rip), %xmm0     # 0x5110
addsd 0x65a6(%rip), %xmm0     # 0x7c98
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x8(%rbp), %xmm2
movsd -0x10(%rbp), %xmm1
mulsd -0x10(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x1080
divsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
callq 0x1030
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x1190
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd 0x39b6(%rip), %xmm1     # 0x5110
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
mulsd 0x3997(%rip), %xmm0     # 0x5118
movsd %xmm0, 0x6507(%rip)     # 0x7c90
movsd -0x20(%rbp), %xmm0
callq 0x1040
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x1190
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
mulsd 0x3953(%rip), %xmm0     # 0x5118
movsd %xmm0, 0x64b3(%rip)     # 0x7c80
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x1040
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
mulsd 0x3923(%rip), %xmm0     # 0x5118
movsd %xmm0, 0x648b(%rip)     # 0x7c88
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::ArgsHandler(ArgsHandler const&)
ArgsHandler::ArgsHandler(const ArgsHandler &args) {
	arguments = args.arguments;
	flags = args.flags;
	startargs = args.startargs;
	execpath = args.execpath;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x5a40
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x48(%rbp)
callq 0x5a60
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x40(%rbp)
callq 0x5a80
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x38(%rbp)
callq 0x22b0
movq -0x28(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0x30(%rbp)
callq 0x5aa0
movq -0x28(%rbp), %rdi
movb $0x0, 0xb0(%rdi)
movq -0x10(%rbp), %rsi
callq 0x5d60
jmp 0x44ae
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x5fb0
jmp 0x44c5
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
addq $0x48, %rdi
callq 0x5fe0
jmp 0x44dc
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
addq $0x60, %rdi
callq 0x2040
jmp 0x44f3
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2f80
movq -0x38(%rbp), %rdi
callq 0x2130
movq -0x40(%rbp), %rdi
callq 0x2fa0
movq -0x48(%rbp), %rdi
callq 0x3000
movq -0x28(%rbp), %rdi
callq 0x2ec0
movq -0x18(%rbp), %rdi
callq 0x2310
nopl (%rax,%rax)
// File: TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlagValueString(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::string ArgsHandler::getFlagValueString(std::string flag, std::string dflt) {
	if (hasFlag(flag)) {
		return flags.find(flag)->second.value;
	} else {
		return dflt;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rcx, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
movq %rsi, %rax
movq -0x88(%rbp), %rsi
movq %rdi, -0x80(%rbp)
movq %rdi, %rdx
movq %rdx, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x20d0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x4540
movb %al, -0x59(%rbp)
jmp 0x4625
leaq -0x40(%rbp), %rdi
callq 0x2130
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x4637
jmp 0x4685
movq -0x88(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
callq 0x62b0
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6310
movq -0x80(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
addq $0x20, %rsi
callq 0x20d0
jmp 0x4695
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2130
jmp 0x46a2
movq -0x90(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x2110
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2310
nopl (%rax,%rax)
// File: TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlagValueInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int ArgsHandler::getFlagValueInt(std::string flag, int dflt) {
	if (hasFlag(flag)) {
		std::string flgstr = flags.find(flag)->second.value;
		int ret = dflt;
		try {
			ret = std::stoi(flgstr);
		} catch (std::invalid_argument &e) {
			// ret is still dflt, so all good.
		}
		return ret;
	} else {
		return dflt;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x20d0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x4540
movb %al, -0x89(%rbp)
jmp 0x4703
leaq -0x40(%rbp), %rdi
callq 0x2130
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x471b
jmp 0x47f4
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdi
addq $0x18, %rdi
callq 0x62b0
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6310
movq %rax, %rsi
addq $0x40, %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x20d0
movq -0xb8(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x7c(%rbp)
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x6330
movl %eax, -0xac(%rbp)
jmp 0x4779
movl -0xac(%rbp), %eax
movl %eax, -0x7c(%rbp)
jmp 0x47cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2130
jmp 0x4806
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x47e9
movq -0x48(%rbp), %rdi
callq 0x20b0
movq %rax, -0x88(%rbp)
callq 0x2300
jmp 0x47ca
jmp 0x47cc
movl -0x7c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2130
jmp 0x47fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2130
jmp 0x4806
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2310
nop
// File: TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlagValueDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
double ArgsHandler::getFlagValueDouble(std::string flag, double dflt) {
	if (hasFlag(flag)) {
		std::string flgstr = flags.find(flag)->second.value;
		double ret = dflt;
		try {
			ret = std::stod(flgstr);
		} catch (std::invalid_argument &e) {
			// ret is still dflt, so all good.
		}
		return ret;
	} else {
		return dflt;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x20d0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x4540
movb %al, -0x89(%rbp)
jmp 0x4865
leaq -0x40(%rbp), %rdi
callq 0x2130
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x487d
jmp 0x495f
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdi
addq $0x18, %rdi
callq 0x62b0
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6310
movq %rax, %rsi
addq $0x40, %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x20d0
movq -0xb8(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x6370
movsd %xmm0, -0xb0(%rbp)
jmp 0x48dc
movsd -0xb0(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
jmp 0x4933
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2130
jmp 0x4977
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4954
movq -0x48(%rbp), %rdi
callq 0x20b0
movq %rax, -0x88(%rbp)
callq 0x2300
jmp 0x4931
jmp 0x4933
movsd -0x80(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2130
jmp 0x4969
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2130
jmp 0x4977
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2310
// File: TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlagValueBool(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
bool ArgsHandler::getFlagValueBool(std::string flag, bool dflt) {
	if (hasFlag(flag)) {
			std::string flgstr = flags.find(flag)->second.value;
			bool ret = dflt;
			if (flgstr == "true") {
				ret = true;
			} else if (flgstr == "false") {
				ret = false;
			}
			return ret;
		} else {
			return dflt;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x98(%rbp)
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x20d0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x4540
movb %al, -0x7a(%rbp)
jmp 0x49d4
leaq -0x40(%rbp), %rdi
callq 0x2130
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0x49e9
jmp 0x4ac4
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
addq $0x18, %rdi
callq 0x62b0
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6310
movq %rax, %rsi
addq $0x40, %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x20d0
movq -0xa8(%rbp), %rdi
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x79(%rbp)
leaq 0x76af(%rip), %rsi      # 0xc0e9
callq 0x63b0
movb %al, -0x99(%rbp)
jmp 0x4a47
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x4a53
jmp 0x4a87
movb $0x1, -0x79(%rbp)
jmp 0x4ab1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2130
jmp 0x4ada
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2130
jmp 0x4ada
leaq 0x7660(%rip), %rsi      # 0xc0ee
leaq -0x70(%rbp), %rdi
callq 0x63b0
movb %al, -0xa9(%rbp)
jmp 0x4a9f
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x4aab
jmp 0x4aaf
movb $0x0, -0x79(%rbp)
jmp 0x4ab1
movb -0x79(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2130
jmp 0x4acc
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
// File: TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlagArguments(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<std::string> ArgsHandler::getFlagArguments(std::string flag) {
	std::vector<std::string> flagArguments;
	if (!hasFlag(flag)) {
		return flagArguments;
	}

	for (int arg:(flags.find(flag)->second.arguments)) {
		flagArguments.push_back(arguments[arg]);
	}

	return flagArguments;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x80(%rbp)
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x5a40
movq -0x80(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x20d0
jmp 0x4b6f
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4540
movb %al, -0x99(%rbp)
jmp 0x4b87
movb -0x99(%rbp), %al
xorb $-0x1, %al
movb %al, -0x9a(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2130
movb -0x9a(%rbp), %al
testb $0x1, %al
jne 0x4baa
jmp 0x4be5
movb $0x1, -0x19(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x4c96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4cb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2130
jmp 0x4cb8
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
addq $0x18, %rdi
callq 0x62b0
movq %rax, -0xa8(%rbp)
jmp 0x4c02
movq -0xa8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6310
addq $0x20, %rax
addq $0x40, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x63e0
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
callq 0x6410
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x6440
testb $0x1, %al
jne 0x4c4f
jmp 0x4c8b
leaq -0x68(%rbp), %rdi
callq 0x6480
movq -0x88(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x74(%rbp)
movslq -0x74(%rbp), %rsi
callq 0x64a0
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0x5b90
jmp 0x4c7e
jmp 0x4c80
leaq -0x68(%rbp), %rdi
callq 0x64c0
jmp 0x4c3c
movb $0x1, -0x19(%rbp)
movl $0x1, -0x50(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x4ca8
movq -0x98(%rbp), %rdi
callq 0x2ec0
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x2ec0
movq -0x48(%rbp), %rdi
callq 0x2310
nopl (%rax)
// File: TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getStartArguments[abi:cxx11]() const
std::vector<std::string> ArgsHandler::getStartArguments() const {
	std::vector<std::string> startArguments;

	for (int arg:startargs) {
		startArguments.push_back(arguments[arg]);
	}

	return startArguments;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5a40
movq -0x50(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x64e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6510
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6540
testb $0x1, %al
jne 0x4d35
jmp 0x4d82
leaq -0x28(%rbp), %rdi
callq 0x6580
movq -0x50(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rsi
callq 0x65a0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x5b90
jmp 0x4d5e
jmp 0x4d60
leaq -0x28(%rbp), %rdi
callq 0x65c0
jmp 0x4d22
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x2ec0
jmp 0x4d9f
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4d95
movq -0x60(%rbp), %rdi
callq 0x2ec0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2310
nopl (%rax,%rax)
// File: TheStanian[P]Args/Args/Args.cpp
// Function: ArgsHandler::getFlags[abi:cxx11]() const
std::vector<std::string> ArgsHandler::getFlags() const {
	std::vector<std::string> strflags;
	for (auto pair:flags) {
		strflags.push_back(pair.first);
	}
	return strflags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5a40
movq -0xc0(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x66d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6700
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6730
testb $0x1, %al
jne 0x4e54
jmp 0x4ece
leaq -0x28(%rbp), %rdi
callq 0x6760
movq %rax, %rsi
leaq -0xa8(%rbp), %rdi
callq 0x6780
jmp 0x4e6e
movq -0xd0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x5b90
jmp 0x4e83
leaq -0xa8(%rbp), %rdi
callq 0x37a0
leaq -0x28(%rbp), %rdi
callq 0x67e0
jmp 0x4e41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x4ef4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x37a0
jmp 0x4ef4
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4ee4
movq -0xd0(%rbp), %rdi
callq 0x2ec0
movq -0xc8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xd0(%rbp), %rdi
callq 0x2ec0
movq -0xb0(%rbp), %rdi
callq 0x2310
nopl (%rax)
// File: TheStanian[P]Args/Args/Args.cpp
// Function: Flag::Flag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Flag::Flag(std::string input) {
	if (input.find("=") != input.npos) {
	name = input.substr(0, input.find_first_of("="));
	value = input.substr(input.find_first_of("=")+1);
	} else {
		name = input;
		value = "";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x22b0
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x80(%rbp)
callq 0x22b0
movq -0x78(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x70(%rbp)
callq 0x5a80
movq -0x68(%rbp), %rdi
leaq 0x7186(%rip), %rsi      # 0xc0e7
xorl %eax, %eax
movl %eax, %edx
callq 0x2360
cmpq $-0x1, %rax
je 0x503d
movq -0x68(%rbp), %rdi
leaq 0x7168(%rip), %rsi      # 0xc0e7
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x88(%rbp)
callq 0x20f0
movq -0x68(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq %rax, %rcx
leaq -0x30(%rbp), %rdi
callq 0x21f0
jmp 0x4fa8
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq %rsi, -0x90(%rbp)
callq 0x2270
movq -0x90(%rbp), %rdi
callq 0x2130
movq -0x68(%rbp), %rdi
leaq 0x7114(%rip), %rsi      # 0xc0e7
xorl %eax, %eax
movl %eax, %edx
callq 0x20f0
movq -0x68(%rbp), %rsi
movq %rax, %rdx
incq %rdx
leaq -0x60(%rbp), %rdi
movq $-0x1, %rcx
callq 0x21f0
jmp 0x4ff8
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
leaq -0x60(%rbp), %rsi
callq 0x2270
leaq -0x60(%rbp), %rdi
callq 0x2130
jmp 0x5064
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x2fa0
movq -0x80(%rbp), %rdi
callq 0x2130
movq -0x78(%rbp), %rdi
callq 0x2130
jmp 0x506d
movq -0x68(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x2040
jmp 0x504c
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
leaq 0x70b7(%rip), %rsi      # 0xc112
callq 0x22a0
jmp 0x5062
jmp 0x5064
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
// File: Tumelo4[P]STACK-IN-CPP/Main.cpp
// Function: main
int main()
{
	Stack* stack = new Stack();
	stack->push(1);
	stack->push(2);
	stack->push(3);
	stack->push(4);
	stack->push(5);
	cout<<*stack<<"\n";

	while(!stack->isEmpty())
	{
		int data = stack->pop();
		if (!stack->isEmpty())
		{
			cout<<data<<",";
		}
		else
		{
			cout<<data;
		}
	}
	cout<<"\n";
	cout<<"Stack is empty: "<<stack->pop()<<"\n";
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0x8, %edi
callq 0x4056f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x404790
jmp 0x4045fa
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x404820
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x404820
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x404820
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x404820
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x404820
movq -0x10(%rbp), %rsi
movq $0x5e3440, %rdi         # imm = 0x5E3440
callq 0x404960
movq %rax, %rdi
leaq 0x178568(%rip), %rsi    # 0x57cbca
callq 0x46d9d0
movq -0x10(%rbp), %rdi
callq 0x404940
xorb $-0x1, %al
testb $0x1, %al
jne 0x404678
jmp 0x4046de
movq -0x10(%rbp), %rdi
callq 0x4048f0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x404940
testb $0x1, %al
jne 0x4046cd
movl -0x20(%rbp), %esi
movq $0x5e3440, %rdi         # imm = 0x5E3440
callq 0x46dd70
movq %rax, %rdi
leaq 0x17195a(%rip), %rsi    # 0x576004
callq 0x46d9d0
jmp 0x4046dc
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x8, %esi
callq 0x4049f0
jmp 0x404733
movl -0x20(%rbp), %esi
movq $0x5e3440, %rdi         # imm = 0x5E3440
callq 0x46dd70
jmp 0x404667
movq $0x5e3440, %rdi         # imm = 0x5E3440
leaq 0x1784de(%rip), %rsi    # 0x57cbca
callq 0x46d9d0
movq $0x5e3440, %rdi         # imm = 0x5E3440
leaq 0x171907(%rip), %rsi    # 0x576006
callq 0x46d9d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4048f0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x46dd70
movq %rax, %rdi
leaq 0x1784a4(%rip), %rsi    # 0x57cbca
callq 0x46d9d0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4a55c0
nopl (%rax)
// File: Tumelo4[P]STACK-IN-CPP/Stack.cpp
// Function: Stack::~Stack()
Stack::~Stack()
{
	while(top)
	{
		Node* tmp = top;
		top = top->next;
		delete tmp;
		tmp = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x404811
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x404807
movq -0x20(%rbp), %rdi
callq 0x404760
movq -0x20(%rbp), %rdi
movl $0x10, %esi
callq 0x4049f0
movq $0x0, -0x10(%rbp)
jmp 0x4047c4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Tumelo4[P]STACK-IN-CPP/Stack.cpp
// Function: Stack::push(int)
void Stack::push(int data)
{
	if (top)
	{
		Node* newNode = new Node(data);
		newNode->next = top;
		top = newNode;
	}
	else
	{
		top = new Node(data);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
je 0x404896
movl $0x10, %edi
callq 0x4056f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0x404740
jmp 0x40485b
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x4048dd
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x4049f0
jmp 0x4048e3
movl $0x10, %edi
callq 0x4056f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
callq 0x404740
jmp 0x4048b4
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x4048dd
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x4049f0
jmp 0x4048e3
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4a55c0
nopl (%rax)
// File: Tumelo4[P]STACK-IN-CPP/Stack.cpp
// Function: Stack::pop()
int Stack::pop()
{
	if(top)
	{
		int data = top->getData();
		top = top->next;
		return data;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x404930
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x404770
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq (%rax), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x404937
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: Tumelo4[P]STACK-IN-CPP/Stack.cpp
// Function: operator<<(std::ostream&, Stack&)
ostream& operator<<(ostream &os, Stack&obj)
{
	for(Node* curr = obj.top; curr!= NULL; curr=curr->next)
	{
		if(curr->next != NULL)
		{
			os<<curr->getData()<<",";
		}
		else os<<curr->getData();
	}
	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4049e4
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4049b9
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x404770
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x46dd70
movq %rax, %rdi
leaq 0x171652(%rip), %rsi    # 0x576004
callq 0x46d9d0
jmp 0x4049d5
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x404770
movq -0x28(%rbp), %rdi
movl %eax, %esi
callq 0x46dd70
jmp 0x4049d7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x40497b
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: brianwu02[P]ImageProcessing/blur.cpp
// Function: main
int main(int argc, char** argv) {
    int xsz, ysz;
    imageP I1, I2, tmp_img;

    xsz = atoi(argv[2]);
    ysz = atoi(argv[3]);

    // bitwise operator to check if xsz & ysz are odd.
    if  (((xsz & 1 ) == 0) or ((ysz & 1) == 0)) {
        // xsz or ysz are even.
        cout << "xsz: " << xsz << endl;
        cout << "ysz: " << ysz << endl;
        cerr << "either xsz or ysz is not odd" << endl;
        exit(1);
    }


    I1 = IP_readImage(argv[1]);
    I2 = NEWIMAGE;
    tmp_img = NEWIMAGE;

    blur(I1, tmp_img, xsz, ysz, I2);

    cout << "done blurring" << endl;

    IP_saveImage(I2, argv[4]);

    IP_freeImage(I1);
    IP_freeImage(I2);
    IP_freeImage(tmp_img);

    cout << "done" << endl;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1150
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1150
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1360
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x13e6
movq 0x3c69(%rip), %rdi      # 0x4fd0
leaq 0x1c96(%rip), %rsi      # 0x3004
callq 0x10a0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1160
movq %rax, %rdi
movq 0x3c38(%rip), %rsi      # 0x4fc0
callq 0x10b0
movq 0x3c3c(%rip), %rdi      # 0x4fd0
leaq 0x1c6f(%rip), %rsi      # 0x300a
callq 0x10a0
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x1160
movq %rax, %rdi
movq 0x3c0b(%rip), %rsi      # 0x4fc0
callq 0x10b0
movq 0x3c2f(%rip), %rdi      # 0x4ff0
leaq 0x1c48(%rip), %rsi      # 0x3010
callq 0x10a0
movq %rax, %rdi
movq 0x3be9(%rip), %rsi      # 0x4fc0
callq 0x10b0
movl $0x1, %edi
callq 0x10e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1ac0
movq %rax, -0x20(%rbp)
movl $0x10, %edi
callq 0x1110
movq %rax, -0x28(%rbp)
movl $0x10, %edi
callq 0x1110
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movq -0x28(%rbp), %r8
callq 0x14b0
movq 0x3b9f(%rip), %rdi      # 0x4fd0
leaq 0x1bf5(%rip), %rsi      # 0x302d
callq 0x10a0
movq %rax, %rdi
movq 0x3b79(%rip), %rsi      # 0x4fc0
callq 0x10b0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x1de0
movq -0x20(%rbp), %rdi
callq 0x1fe0
movq -0x28(%rbp), %rdi
callq 0x1fe0
movq -0x30(%rbp), %rdi
callq 0x1fe0
movq 0x3b51(%rip), %rdi      # 0x4fd0
leaq 0x1bb5(%rip), %rsi      # 0x303b
callq 0x10a0
movq %rax, %rdi
movq 0x3b2b(%rip), %rsi      # 0x4fc0
callq 0x10b0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: brianwu02[P]ImageProcessing/IPutil.cpp
// Function: IP_allocImage(int, int, int)
imageP
IP_allocImage(int w, int h, int s)
{
	uchar	*p;
	imageP	 I;

	// allocate memory
	I = (imageP ) malloc(sizeof(imageS));
	p = (uchar *) malloc(w * h * s);
	if(p == NULL) {
		cerr << "IP_allocImage: Insufficient memory\n";
		return ((imageP) NULL);
	}

	// init structure
	I->width  = w;
	I->height = h;
	I->image  = p;

	return(I);
}

// 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 0x1110
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
movslq %eax, %rdi
callq 0x1110
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1daa
movq 0x325c(%rip), %rdi      # 0x4ff0
leaq 0x131e(%rip), %rsi      # 0x30b9
callq 0x10a0
movq $0x0, -0x8(%rbp)
jmp 0x1dd1
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
nopl (%rax,%rax)
// File: brianwu02[P]ImageProcessing/IPutil.cpp
// Function: IP_saveImage(imageS*, char*)
void 
IP_saveImage(imageP I, char *file)
{

	uchar	*out;

	// open binary file for writing
	ofstream outFile(file, ios::binary);

	// error checking
	if (!outFile) {
		cerr << "IP_savePGM: Can't open " << file << endl;
		exit(1);
	}

	// save PGM header
	outFile <<"P5" << endl;
	outFile <<I->width<< " " << I->height << endl;
	outFile << "255" << endl;

	// save image data
	out = I->image;
	outFile.write((char *) out, I->width*I->height);
	outFile.close();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x4, %edx
callq 0x10c0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x1060
movb %al, -0x225(%rbp)
jmp 0x1e28
movb -0x225(%rbp), %al
testb $0x1, %al
jne 0x1e34
jmp 0x1eab
movq 0x31b5(%rip), %rdi      # 0x4ff0
leaq 0x125b(%rip), %rsi      # 0x309d
callq 0x10a0
movq %rax, -0x230(%rbp)
jmp 0x1e50
movq -0x230(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10a0
movq %rax, -0x238(%rbp)
jmp 0x1e69
movq -0x238(%rbp), %rdi
movq 0x3149(%rip), %rsi      # 0x4fc0
callq 0x10b0
jmp 0x1e7e
movl $0x1, %edi
callq 0x10e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x1130
jmp 0x1fc5
leaq 0x11c5(%rip), %rsi      # 0x3077
leaq -0x218(%rbp), %rdi
callq 0x10a0
movq %rax, -0x240(%rbp)
jmp 0x1ec7
movq -0x240(%rbp), %rdi
movq 0x30eb(%rip), %rsi      # 0x4fc0
callq 0x10b0
jmp 0x1edc
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq -0x218(%rbp), %rdi
callq 0x1160
movq %rax, -0x248(%rbp)
jmp 0x1ef7
movq -0x248(%rbp), %rdi
leaq 0x1159(%rip), %rsi      # 0x305e
callq 0x10a0
movq %rax, -0x250(%rbp)
jmp 0x1f13
movq -0x250(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x1160
movq %rax, -0x258(%rbp)
jmp 0x1f2f
movq -0x258(%rbp), %rdi
movq 0x3083(%rip), %rsi      # 0x4fc0
callq 0x10b0
jmp 0x1f44
leaq 0x116a(%rip), %rsi      # 0x30b5
leaq -0x218(%rbp), %rdi
callq 0x10a0
movq %rax, -0x260(%rbp)
jmp 0x1f60
movq -0x260(%rbp), %rdi
movq 0x3052(%rip), %rsi      # 0x4fc0
callq 0x10b0
jmp 0x1f75
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rcx
movl (%rcx), %eax
movl 0x4(%rcx), %ecx
imull %ecx, %eax
movslq %eax, %rdx
leaq -0x218(%rbp), %rdi
callq 0x1100
jmp 0x1fa2
leaq -0x218(%rbp), %rdi
callq 0x1120
jmp 0x1fb0
leaq -0x218(%rbp), %rdi
callq 0x1130
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x1170
nopw %cs:(%rax,%rax)
// File: sweeterthancandy[P]linux_event_debugger/linux_events.cpp
// Function: (anonymous namespace)::driver::start_monitor_()
void start_monitor_(){
                mon_ = std::make_shared<directory_monitor>(io_, "/dev/input");
                mon_->connect([this](tag t, std::string const& dir){
                        process_event_(t, dir);
                });
                mon_->start();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x90(%rbp)
leaq 0x4f02e(%rip), %rdx     # 0x60baf
leaq -0x18(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x11f10
movq -0xa0(%rbp), %rsi
movq -0x90(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x98(%rbp)
callq 0x11f90
movq -0xa0(%rbp), %rdi
callq 0x11fc0
movq -0x98(%rbp), %rdi
callq 0x11fe0
movq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, -0x88(%rbp)
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x12040
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x12000
jmp 0x11c03
leaq -0x28(%rbp), %rdi
callq 0x2ff80
leaq -0x60(%rbp), %rdi
callq 0x120c0
movq -0x90(%rbp), %rdi
addq $0x60, %rdi
callq 0x11fe0
movq %rax, %rdi
callq 0x120f0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x120c0
movq -0x70(%rbp), %rdi
callq 0xdb80
nopw %cs:(%rax,%rax)
// File: sweeterthancandy[P]linux_event_debugger/linux_events.cpp
// Function: (anonymous namespace)::driver::create_existing_()
void create_existing_(){
                namespace bf = boost::filesystem;
                for(bf::directory_iterator iter("/dev/input/"),end;iter!=end;++iter){
                        auto p = iter->path();
                        auto dev = p.filename().string();
                       
                      
                        if( ! bf::is_directory( iter->path() ) )
                        {
                                process_event_(tag_existing, iter->path().string());
                        }
                }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq 0x5684a(%rip), %rsi     # 0x684cb
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x58440
movq -0xb0(%rbp), %rsi
leaq -0x10(%rbp), %rdi
xorl %edx, %edx
callq 0x584b0
jmp 0x11ca5
leaq -0x30(%rbp), %rdi
callq 0x58510
leaq -0x48(%rbp), %rdi
callq 0x58530
leaq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x58550
movb %al, -0xb9(%rbp)
jmp 0x11ccc
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x11d1a
jmp 0x11cd8
leaq -0x48(%rbp), %rdi
callq 0x58670
leaq -0x10(%rbp), %rdi
callq 0x58670
jmp 0x11e9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x58510
jmp 0x11ea4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x11e87
leaq -0x10(%rbp), %rdi
callq 0x58590
movq %rax, -0xc8(%rbp)
jmp 0x11d2c
movq -0xc8(%rbp), %rdi
callq 0x585c0
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0x585d0
jmp 0x11d46
leaq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xd560
jmp 0x11d58
leaq -0xa8(%rbp), %rdi
callq 0x58600
movq %rax, -0xd0(%rbp)
jmp 0x11d6d
movq -0xd0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0xd280
jmp 0x11d82
leaq -0xa8(%rbp), %rdi
callq 0x58510
leaq -0x10(%rbp), %rdi
callq 0x58590
movq %rax, -0xd8(%rbp)
jmp 0x11da0
movq -0xd8(%rbp), %rdi
callq 0x585c0
movq %rax, %rdi
callq 0x58610
movb %al, -0xd9(%rbp)
jmp 0x11dbc
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x11e59
jmp 0x11dcc
leaq -0x10(%rbp), %rdi
callq 0x58590
movq %rax, -0xe8(%rbp)
jmp 0x11dde
movq -0xe8(%rbp), %rdi
callq 0x585c0
movq %rax, %rdi
callq 0x58600
movq %rax, -0xf0(%rbp)
jmp 0x11dfb
movq -0xf0(%rbp), %rdx
movq -0xb8(%rbp), %rdi
movl $0x2, %esi
callq 0x193a0
jmp 0x11e15
jmp 0x11e59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x11e7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x58510
jmp 0x11e7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xd3b0
jmp 0x11e7e
leaq -0x88(%rbp), %rdi
callq 0xd3b0
leaq -0x68(%rbp), %rdi
callq 0x58510
leaq -0x10(%rbp), %rdi
callq 0x58640
jmp 0x11e79
jmp 0x11cb7
leaq -0x68(%rbp), %rdi
callq 0x58510
leaq -0x48(%rbp), %rdi
callq 0x58670
leaq -0x10(%rbp), %rdi
callq 0x58670
jmp 0x11ea4
addq $0xf0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xdb80
nopl (%rax)
// File: sweeterthancandy[P]linux_event_debugger/linux_events.cpp
// Function: (anonymous namespace)::driver::start_signal_monitor_()
void start_signal_monitor_(){
                signals_.add( SIGINT );
                signals_.add( SIGTERM );
                signals_.async_wait( [this](const boost::system::error_code& ec, int sig){
                        switch(sig){
                                case SIGINT:
                                case SIGTERM:
                                        mon_->stop();
                                        mon_.reset();
                                        for( auto& p : monitors_ ){
                                                p.second->stop();
                                        }
                                        monitors_.clear();
                                        break;
                                default:
                                        assert( 0 && "unexpcted signal");
                        }
                });
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x10, %rdi
movl $0x2, %esi
callq 0x58b30
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movl $0xf, %esi
callq 0x58b30
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x10, %rdi
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x1d1f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sweeterthancandy[P]linux_event_debugger/linux_events.cpp
// Function: (anonymous namespace)::directory_monitor::directory_monitor(boost::asio::io_context&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
explicit directory_monitor(boost::asio::io_service& io_, const std::string& dir)
                :io_(io_)
                ,work_(io_) // keep alive
                ,timer_(io_)
        {
                fd = inotify_init();

                wd = inotify_add_watch( fd, dir_.c_str(), 
                                        IN_MODIFY | IN_CREATE | IN_DELETE );

                time_to_wait.tv_sec = 0;
                time_to_wait.tv_usec = 0;

        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x12ba0
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xdbb0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x4e156(%rip), %rsi     # 0x60baf
callq 0x1e790
jmp 0x12a60
leaq -0x19(%rbp), %rdi
callq 0xd6f0
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x30(%rdi)
addq $0x38, %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0x30020
jmp 0x12a88
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x58(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x30050
jmp 0x12aa3
movq -0x48(%rbp), %rdi
movb $0x1, 0x40b0(%rdi)
movq $0x0, 0x4140(%rdi)
movq $0x0, 0x4148(%rdi)
addq $0x4150, %rdi           # imm = 0x4150
leaq -0x2d(%rbp), %rsi
leaq -0x2e(%rbp), %rdx
callq 0x12bc0
jmp 0x12ada
callq 0xdbe0
movq -0x48(%rbp), %rdi
movl %eax, 0x40b4(%rdi)
movl 0x40b4(%rdi), %eax
movl %eax, -0x5c(%rbp)
addq $0x10, %rdi
callq 0xd260
movl -0x5c(%rbp), %edi
movq %rax, %rsi
movl $0x302, %edx            # imm = 0x302
callq 0xd320
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x40b8(%rax)
movq $0x0, 0x4140(%rax)
movq $0x0, 0x4148(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0xd6f0
jmp 0x12b8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x12b84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x12b7b
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x30080
movq -0x50(%rbp), %rdi
callq 0x300a0
movq -0x40(%rbp), %rdi
callq 0xd3b0
movq -0x48(%rbp), %rdi
callq 0x12c70
movq -0x28(%rbp), %rdi
callq 0xdb80
nop