LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mniip[P]sandbox/sandbox.cpp
// Function: ThreadData::ptrace(int, void*, void*)
long ThreadData::ptrace(int request, void *addr, void *data)
{
	errno = 0;
	long result = ::ptrace((enum __ptrace_request)request, tid, addr, data);
	if(errno == ESRCH)
		throw ThreadGone(tid);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x5060
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl $0x0, (%rcx)
movl -0xc(%rbp), %edi
movl (%rax), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb $0x0, %al
callq 0x5430
movq %rax, -0x28(%rbp)
callq 0x5060
cmpl $0x3, (%rax)
jne 0x13202
movl $0x18, %edi
callq 0x5280
movq %rax, %rdi
movq -0x40(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movl (%rax), %esi
callq 0x13570
jmp 0x131d4
movq -0x48(%rbp), %rdi
leaq 0x13b31(%rip), %rsi     # 0x26d10
leaq 0x3da(%rip), %rdx       # 0x135c0
callq 0x58b0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x5360
jmp 0x1320c
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: mniip[P]sandbox/sandbox.cpp
// Function: ThreadData::set_options()
void ThreadData::set_options()
{
	if(!set_opts)
	{
		if(!ptrace_setoptions(PTRACE_O_EXITKILL | PTRACE_O_TRACECLONE | PTRACE_O_TRACEEXEC | PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK))
			panic_errno("ptrace SETOPTIONS");
		set_opts = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, 0x5(%rax)
jne 0x13508
movq -0x48(%rbp), %rdi
movl $0x10001e, %esi         # imm = 0x10001E
callq 0x13220
testb $0x1, %al
jne 0x13500
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5900
movq -0x50(%rbp), %rdx
leaq 0x8ef1(%rip), %rsi      # 0x1c399
leaq -0x28(%rbp), %rdi
callq 0x72d0
jmp 0x134b3
leaq -0x28(%rbp), %rdi
callq 0x130c0
jmp 0x134be
leaq -0x28(%rbp), %rdi
callq 0x59b8
leaq -0x29(%rbp), %rdi
callq 0x5560
jmp 0x13500
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x134f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x59b8
leaq -0x29(%rbp), %rdi
callq 0x5560
jmp 0x1350e
movq -0x48(%rbp), %rax
movb $0x1, 0x5(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x58f0
nopw (%rax,%rax)
// File: mniip[P]sandbox/path.cpp
// Function: read_link(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool read_link(std::string path, std::string &out)
{
	int fd = open(path.c_str(), O_PATH | O_NOFOLLOW);
	if(fd < 0)
		return false;
	struct stat stat;
	if(fstat(fd, &stat))
	{
		close(fd);
		return false;
	}
	if((stat.st_mode & S_IFMT) != S_IFLNK)
	{
		close(fd);
		return false;
	}
	size_t size = stat.st_size;
	if(!size)
		size++;
	char *buf = (char *)malloc(size + 1);
	ssize_t sz;
	while(1)
	{
		sz = readlinkat(fd, "", buf, size + 1);
		if(sz < 0)
		{
			close(fd);
			free(buf);
			return false;
		}
		if(sz > size)
		{
			size *= 2;
			buf = (char *)realloc(buf, size + 1);
		}
		else
			break;
	}
	close(fd);
	out.assign(buf, sz);
	free(buf);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x5200
movq %rax, %rdi
movl $0x220000, %esi         # imm = 0x220000
movb $0x0, %al
callq 0x5370
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x13649
movb $0x0, -0x1(%rbp)
jmp 0x13792
movl -0x1c(%rbp), %edi
leaq -0xb0(%rbp), %rsi
callq 0x5880
cmpl $0x0, %eax
je 0x1366e
movl -0x1c(%rbp), %edi
callq 0x5970
movb $0x0, -0x1(%rbp)
jmp 0x13792
movl -0x98(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xa000, %eax           # imm = 0xA000
je 0x13691
movl -0x1c(%rbp), %edi
callq 0x5970
movb $0x0, -0x1(%rbp)
jmp 0x13792
movq -0x80(%rbp), %rax
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0xb8(%rbp)
jne 0x136b8
movq -0xb8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rdi
addq $0x1, %rdi
callq 0x5690
movq %rax, -0xc0(%rbp)
movl -0x1c(%rbp), %edi
movq -0xc0(%rbp), %rdx
movq -0xb8(%rbp), %rcx
addq $0x1, %rcx
leaq 0x89b4(%rip), %rsi      # 0x1c09f
callq 0x50f0
movq %rax, -0xc8(%rbp)
cmpq $0x0, -0xc8(%rbp)
jge 0x1371b
movl -0x1c(%rbp), %edi
callq 0x5970
movq -0xc0(%rbp), %rdi
callq 0x55d0
movb $0x0, -0x1(%rbp)
jmp 0x13792
movq -0xc8(%rbp), %rax
cmpq -0xb8(%rbp), %rax
jbe 0x1375c
movq -0xb8(%rbp), %rax
shlq %rax
movq %rax, -0xb8(%rbp)
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
addq $0x1, %rsi
callq 0x5870
movq %rax, -0xc0(%rbp)
jmp 0x1375e
jmp 0x13763
jmp 0x136cf
movl -0x1c(%rbp), %edi
callq 0x5970
movq -0x18(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0x56b0
movq -0xc0(%rbp), %rdi
callq 0x55d0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
// File: mniip[P]sandbox/wakeup.cpp
// Function: feed_data(int, int, bool, bool)
void feed_data(int from, int to, bool track, bool closeeof)
{
	const size_t BLOCK_SIZE = 4096;
	char buffer[BLOCK_SIZE];
	ssize_t bytes_read;
	while(0 < (bytes_read = read(from, buffer, BLOCK_SIZE)))
	{
		size_t done = 0;
		while(done < bytes_read)
		{
			ssize_t bytes_wrote = write(to, buffer + done, bytes_read - done);
			if(bytes_wrote <= 0)
			{
				printf("[Write error]\n");
				exit(0);
			}
			done += bytes_wrote;
			if(track)
				written += bytes_wrote;
		}
	}
	if(bytes_read < 0 && errno != EAGAIN)
	{
		printf("[Read error]\n");
		exit(0);
	}
	if(closeeof)
	{
		close_input = true;
		if(startup_over)
			close(to);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movb %cl, %al
movb %dl, %cl
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq $0x1000, -0x18(%rbp)    # imm = 0x1000
movl -0x4(%rbp), %edi
leaq -0x1020(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x5770
movq %rax, %rcx
movq %rcx, -0x1028(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jge 0x145b6
movq $0x0, -0x1030(%rbp)
movq -0x1030(%rbp), %rax
cmpq -0x1028(%rbp), %rax
jae 0x145b1
movl -0x8(%rbp), %edi
leaq -0x1020(%rbp), %rsi
addq -0x1030(%rbp), %rsi
movq -0x1028(%rbp), %rdx
subq -0x1030(%rbp), %rdx
callq 0x51c0
movq %rax, -0x1038(%rbp)
cmpq $0x0, -0x1038(%rbp)
jg 0x1457a
leaq 0x7e61(%rip), %rdi      # 0x1c3cd
movb $0x0, %al
callq 0x5070
xorl %edi, %edi
callq 0x55e0
movq -0x1038(%rbp), %rax
addq -0x1030(%rbp), %rax
movq %rax, -0x1030(%rbp)
testb $0x1, -0x9(%rbp)
je 0x145ac
movq -0x1038(%rbp), %rcx
movslq 0x12fd1(%rip), %rax     # 0x27574
addq %rcx, %rax
movl %eax, 0x12fc8(%rip)     # 0x27574
jmp 0x1451c
jmp 0x144e8
cmpq $0x0, -0x1028(%rbp)
jge 0x145df
callq 0x5060
cmpl $0xb, (%rax)
je 0x145df
leaq 0x7e0b(%rip), %rdi      # 0x1c3dc
movb $0x0, %al
callq 0x5070
xorl %edi, %edi
callq 0x55e0
testb $0x1, -0xa(%rbp)
je 0x145ff
movb $0x1, 0x12f8c(%rip)     # 0x27578
testb $0x1, 0x12f7d(%rip)     # 0x27570
je 0x145fd
movl -0x8(%rbp), %edi
callq 0x5970
jmp 0x145ff
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nopl (%rax,%rax)
// File: mniip[P]sandbox/wakeup.cpp
// Function: check_startup()
void check_startup()
{
	if(!startup_over)
	{
		int buffer;
		if(ioctl(in_pipe[1], FIONREAD, &buffer))
			panic_errno("FIONREAD");
		if(buffer - written < 0)
		{
			if(close_input)
				close(in_pipe[1]);
			startup_over = true;
			set_timer();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
testb $0x1, 0x11f91(%rip)     # 0x27570
jne 0x156a0
movl 0x11f69(%rip), %edi     # 0x27554
movl $0x541b, %esi           # imm = 0x541B
leaq -0x4(%rbp), %rdx
movb $0x0, %al
callq 0x5730
cmpl $0x0, %eax
je 0x15670
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x5900
movq -0x48(%rbp), %rdx
leaq 0x6e23(%rip), %rsi      # 0x1c43b
leaq -0x28(%rbp), %rdi
callq 0x72d0
jmp 0x15623
leaq -0x28(%rbp), %rdi
callq 0x130c0
jmp 0x1562e
leaq -0x28(%rbp), %rdi
callq 0x59b8
leaq -0x29(%rbp), %rdi
callq 0x5560
jmp 0x15670
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x15665
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x59b8
leaq -0x29(%rbp), %rdi
callq 0x5560
jmp 0x156a6
movl -0x4(%rbp), %eax
subl 0x11efb(%rip), %eax     # 0x27574
cmpl $0x0, %eax
jge 0x1569e
testb $0x1, 0x11ef3(%rip)     # 0x27578
je 0x15692
movl 0x11ec7(%rip), %edi     # 0x27554
callq 0x5970
movb $0x1, 0x11ed7(%rip)     # 0x27570
callq 0x14670
jmp 0x156a0
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x58f0
nop
// File: mniip[P]sandbox/config.cpp
// Function: skip_block_until(std::basic_ifstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static void skip_block_until(std::ifstream &file, std::string until)
{
	std::string line;
	while(std::getline(file, line))
	{
		std::istringstream iss(line);
		std::string key;
		if(!(iss >> key)) continue;
		if(key == until) break;

		if(key == "ident")
			skip_block_until(file, "end");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rsi, -0x218(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5700
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x50d0
movq %rax, -0x220(%rbp)
jmp 0x16319
movq -0x220(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5620
movb %al, -0x221(%rbp)
jmp 0x16337
movb -0x221(%rbp), %al
testb $0x1, %al
jne 0x16346
jmp 0x1652e
leaq -0x1c0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x8, %edx
callq 0x5890
jmp 0x1635d
leaq -0x1e0(%rbp), %rdi
movq %rdi, -0x238(%rbp)
callq 0x5700
movq -0x238(%rbp), %rsi
leaq -0x1c0(%rbp), %rdi
callq 0x5630
movq %rax, -0x230(%rbp)
jmp 0x1638c
movq -0x230(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5240
movb %al, -0x239(%rbp)
jmp 0x163aa
movb -0x239(%rbp), %al
testb $0x1, %al
jne 0x163b6
jmp 0x163e7
movl $0x2, -0x1e4(%rbp)
jmp 0x164d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x16540
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x16514
movq -0x218(%rbp), %rsi
leaq -0x1e0(%rbp), %rdi
callq 0x14330
testb $0x1, %al
jne 0x16400
jmp 0x1640f
movl $0x3, -0x1e4(%rbp)
jmp 0x164d2
leaq -0x1e0(%rbp), %rdi
leaq 0x60d5(%rip), %rsi      # 0x1c4f2
callq 0x72a0
testb $0x1, %al
jne 0x1642b
jmp 0x164c8
movq -0x8(%rbp), %rax
movq %rax, -0x250(%rbp)
leaq -0x209(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x5900
movq -0x248(%rbp), %rdx
leaq 0x60a1(%rip), %rsi      # 0x1c4f8
leaq -0x208(%rbp), %rdi
callq 0x72d0
jmp 0x16465
movq -0x250(%rbp), %rdi
leaq -0x208(%rbp), %rsi
callq 0x162e0
jmp 0x1647a
leaq -0x208(%rbp), %rdi
callq 0x59b8
leaq -0x209(%rbp), %rdi
callq 0x5560
jmp 0x164c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x164ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x59b8
leaq -0x209(%rbp), %rdi
callq 0x5560
jmp 0x16514
movl $0x0, -0x1e4(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x59b8
leaq -0x1c0(%rbp), %rdi
callq 0x5260
movl -0x1e4(%rbp), %eax
movl %eax, -0x254(%rbp)
testl %eax, %eax
je 0x1650f
jmp 0x164fc
movl -0x254(%rbp), %eax
subl $0x2, %eax
je 0x16303
jmp 0x1650d
jmp 0x1652e
jmp 0x16303
leaq -0x1e0(%rbp), %rdi
callq 0x59b8
leaq -0x1c0(%rbp), %rdi
callq 0x5260
jmp 0x16540
leaq -0x30(%rbp), %rdi
callq 0x59b8
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x59b8
movq -0x38(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)
// File: simap[P]ecctools/make_keys.cpp
// Function: printHex(unsigned char*, int)
void printHex(uint8_t * data, int len) {
  int i;
  printf("{\n\t");
  for(i=0; i<len-1; ++i) {
    printf("0x%02X, ", data[i]);
    if ((i+1) % 11 == 0)
      printf("\n\t");
  }
  printf("0x%02X};\n", data[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x5dde(%rip), %rdi      # 0x7004
movb $0x0, %al
callq 0x1030
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1289
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x5db4(%rip), %rdi      # 0x7008
movb $0x0, %al
callq 0x1030
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl $0xb, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x127c
leaq 0x5d90(%rip), %rdi      # 0x7005
movb $0x0, %al
callq 0x1030
jmp 0x127e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1234
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x5d75(%rip), %rdi      # 0x7011
movb $0x0, %al
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: simap[P]ecctools/make_keys.cpp
// Function: main
int main(int argc, char ** argv) {
  if (argc < 2) {
    fprintf(stderr, "Need a key name\n");
    return -1;
  }

  if (uECC_get_rng() == NULL) {
    fprintf(stderr, "Compiled without a random number generator!\n");
    return -1;
  }

  const struct uECC_Curve_t * curve = uECC_secp256k1();
  uint8_t private1[32];
  uint8_t public1[64];
  
  uECC_make_key(public1, private1, curve);


  char tmp[100];
  FILE * fp;

  sprintf(tmp, "%s.pub", argv[1]);
  fp = fopen (tmp, "wb");
  fwrite(public1, 64, 1, fp);
  fclose(fp);

  sprintf(tmp, "%s.key", argv[1]);
  fp = fopen (tmp, "wb");
  fwrite(private1, 32, 1, fp);
  fclose(fp);


  printf("const unsigned char private_key[] = ");
  printHex(private1, 32);

  printf("const unsigned char public_key[] = ");
  printHex(public1, 64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x12f3
movq 0x8d0a(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
leaq 0x5d3b(%rip), %rsi      # 0x701b
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x142e
callq 0x1460
cmpq $0x0, %rax
jne 0x1322
movq 0x8cdb(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
leaq 0x5d1d(%rip), %rsi      # 0x702c
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x142e
callq 0x14f0
movq %rax, -0x18(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1500
leaq -0xf0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x5d07(%rip), %rsi      # 0x7059
movb $0x0, %al
callq 0x1040
leaq -0xf0(%rbp), %rdi
leaq 0x5cf9(%rip), %rsi      # 0x7060
callq 0x10c0
movq %rax, -0xf8(%rbp)
leaq -0x80(%rbp), %rdi
movq -0xf8(%rbp), %rcx
movl $0x40, %esi
movl $0x1, %edx
callq 0x10f0
movq -0xf8(%rbp), %rdi
callq 0x10a0
leaq -0xf0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x5cb4(%rip), %rsi      # 0x7063
movb $0x0, %al
callq 0x1040
leaq -0xf0(%rbp), %rdi
leaq 0x5c9c(%rip), %rsi      # 0x7060
callq 0x10c0
movq %rax, -0xf8(%rbp)
leaq -0x40(%rbp), %rdi
movq -0xf8(%rbp), %rcx
movl $0x20, %esi
movl $0x1, %edx
callq 0x10f0
movq -0xf8(%rbp), %rdi
callq 0x10a0
leaq 0x5c6d(%rip), %rdi      # 0x706a
movb $0x0, %al
callq 0x1030
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x1210
leaq 0x5c76(%rip), %rdi      # 0x708f
movb $0x0, %al
callq 0x1030
leaq -0x80(%rbp), %rdi
movl $0x40, %esi
callq 0x1210
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw (%rax,%rax)
// File: eecs280staff[P]unit_test_framework/test/char_array.cpp
// Function: string_eq()
TEST(string_eq) {
    char arr[] = "spam";
    ASSERT_SEQUENCE_EQUAL("spam", "spam");
    ASSERT_SEQUENCE_EQUAL("spam", arr);
    ASSERT_SEQUENCE_EQUAL("spam", string("spam"));
    ASSERT_EQUAL("spam", string("spam"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb $0x0, -0x4(%rbp)
movl $0x6d617073, -0x8(%rbp) # imm = 0x6D617073
leaq 0x84a2(%rip), %rsi      # 0xc07f
movq %rsi, -0x78(%rbp)
leaq 0x849c(%rip), %rcx      # 0xc084
movl $0xb, %edx
movq %rsi, %rdi
callq 0x54f0
movq -0x78(%rbp), %rdi
leaq 0x84aa(%rip), %rcx      # 0xc0aa
leaq -0x8(%rbp), %rsi
movl $0xc, %edx
callq 0x5990
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x33f0
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x4010
jmp 0x3c2e
leaq 0x844a(%rip), %rdi      # 0xc07f
leaq 0x8491(%rip), %rcx      # 0xc0cd
leaq -0x28(%rbp), %rsi
movl $0xd, %edx
callq 0x5e30
jmp 0x3c4c
leaq -0x28(%rbp), %rdi
callq 0x3160
leaq -0x29(%rbp), %rdi
callq 0x32a0
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x33f0
movq -0x80(%rbp), %rdx
leaq 0x8409(%rip), %rsi      # 0xc07f
leaq -0x60(%rbp), %rdi
callq 0x4010
jmp 0x3c81
leaq 0x83f7(%rip), %rdi      # 0xc07f
leaq 0x846c(%rip), %rcx      # 0xc0fb
leaq -0x60(%rbp), %rsi
movl $0xe, %edx
callq 0x6300
jmp 0x3c9f
leaq -0x60(%rbp), %rdi
callq 0x3160
leaq -0x61(%rbp), %rdi
callq 0x32a0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3cdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3160
leaq -0x29(%rbp), %rdi
callq 0x32a0
jmp 0x3d14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3d0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3160
leaq -0x61(%rbp), %rdi
callq 0x32a0
movq -0x38(%rbp), %rdi
callq 0x33e0
nopl (%rax)
// File: eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: std::ostream& unit_test_framework::Diagnostic::print_helper<5ul>(std::ostream&, char const (&) [5ul], int, int)
static std::ostream& print_helper(std::ostream& os, const char (&arr)[N],
                                      int, int) {
      for (std::size_t i = 0; i < N; ++i) {
        if (!arr[i]) {
          return os << arr;
        }
      }
      return print_sequence_helper(os, arr);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x5, -0x28(%rbp)
jae 0x6656
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x6646
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3230
movq %rax, -0x8(%rbp)
jmp 0x6667
jmp 0x6648
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x661e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6680
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: tobias93[P]piano/./Audio.hpp
// Function: playFromSource(void*, void*, unsigned int, double, unsigned int, void*)
int playFromSource(void *outputBuffer, void *inputBuffer, unsigned int nBufferFrames, double streamTime, RtAudioStreamStatus status, void *userData)
{
    double * buffer = (double *) outputBuffer;
    AudioSource& source = *(AudioSource*)userData;

    if (status)
    {
        std::cerr << "Stream underflow detected!" << std::endl;
    }
    
    return source.fillBuffer(buffer, nBufferFrames);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movsd %xmm0, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x349e
movq 0x3b65(%rip), %rdi      # 0x6fe8
leaq 0x1bae(%rip), %rsi      # 0x5038
callq 0x31a0
movq %rax, %rdi
movq 0x3aff(%rip), %rsi      # 0x6f98
callq 0x31b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x34(%rsp), %edx
movq (%rdi), %rax
callq *(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tobias93[P]piano/./Midi.hpp
// Function: process_midi(double, std::vector<unsigned char, std::allocator<unsigned char>>*, void*)
void process_midi(double deltatime, std::vector<unsigned char> * message_ptr, void * userData)
{
    if (userData == nullptr)
    {
        return;
    }
    MidiListener& listener = *(MidiListener *) userData;
    
    std::vector<unsigned char>& message = *message_ptr;
    if (message.size() != 3) {
        std::cout << "WARNING: Encountered malformed MIDI message." << std::endl;
        return;
    }

    unsigned char note = message[1];
    unsigned char velocity = message[2];

    if ((message[0] & 0xF0) == 0x80)
    {
        // Note Off
        listener.noteOff(note);
    }

    if ((message[0] & 0xF0) == 0x90)
    {
        // Note On
        listener.noteOn(note, velocity);
    }

}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x34e1
jmp 0x35ba
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x37d0
cmpq $0x3, %rax
je 0x352c
movq 0x3aac(%rip), %rdi      # 0x6fb8
leaq 0x1b40(%rip), %rsi      # 0x5053
callq 0x31a0
movq %rax, %rdi
movq 0x3a76(%rip), %rsi      # 0x6f98
callq 0x31b0
jmp 0x35ba
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x37f0
movb (%rax), %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x37f0
movb (%rax), %al
movb %al, 0xe(%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x37f0
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0x80, %eax
jne 0x3585
movq 0x18(%rsp), %rdi
movb 0xf(%rsp), %cl
movq (%rdi), %rax
movzbl %cl, %esi
callq *0x8(%rax)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x37f0
movzbl (%rax), %eax
andl $0xf0, %eax
cmpl $0x90, %eax
jne 0x35ba
movq 0x18(%rsp), %rdi
movb 0xf(%rsp), %dl
movb 0xe(%rsp), %cl
movq (%rdi), %rax
movzbl %dl, %esi
movzbl %cl, %edx
callq *(%rax)
addq $0x38, %rsp
retq
nop
// File: tobias93[P]piano/main.cpp
// Function: main
int main()
{
    MidiIn midi;
    SimpleSynth synth;
    AudioPlayer player;

    AudioSettings audioSettings;
    audioSettings.bufferFrames = 64;
    player.setAudioSettings(audioSettings);

    Envelope envelope;
    envelope.amplitude = 1;
    envelope.sustain = .5;
    envelope.attack = 0.1;
    envelope.decay = 0.6;
    envelope.release = 2;
    synth.setEnvelope(envelope);
    
    player.setAudioSource(&synth);
    midi.setMidiListener(&synth);
    
    midi.connect_interactive();
    player.play();

    cout << "Have fun playing some music!." << endl;
    cout << "Press [enter] to exit." << endl;

    cin.get();

    return 0;
}

// Assembly:
subq $0x168, %rsp            # imm = 0x168
movl $0x0, 0x164(%rsp)
leaq 0x148(%rsp), %rdi
callq 0x3810
leaq 0x88(%rsp), %rdi
callq 0x38d0
leaq 0x68(%rsp), %rdi
callq 0x3940
jmp 0x35f8
leaq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x3a30
movq 0x20(%rsp), %rsi
movl $0x40, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x3a50
jmp 0x3620
leaq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3aa0
movq 0x18(%rsp), %rsi
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x28(%rsp)
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, 0x40(%rsp)
movabsq $0x3fb999999999999a, %rax # imm = 0x3FB999999999999A
movq %rax, 0x30(%rsp)
movabsq $0x3fe3333333333333, %rax # imm = 0x3FE3333333333333
movq %rax, 0x38(%rsp)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, 0x48(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x3ae0
jmp 0x368e
leaq 0x68(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x3b10
jmp 0x36a2
xorl %eax, %eax
leaq 0x88(%rsp), %rcx
cmpq $0x0, %rcx
movq %rax, 0x10(%rsp)
je 0x36c8
leaq 0x88(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
leaq 0x148(%rsp), %rdi
callq 0x3b50
jmp 0x36dc
leaq 0x148(%rsp), %rdi
callq 0x3b90
jmp 0x36eb
leaq 0x68(%rsp), %rdi
callq 0x3d70
jmp 0x36f7
movq 0x38ba(%rip), %rdi      # 0x6fb8
leaq 0x197b(%rip), %rsi      # 0x5080
callq 0x31a0
movq %rax, 0x8(%rsp)
jmp 0x3711
movq 0x8(%rsp), %rdi
movq 0x387b(%rip), %rsi      # 0x6f98
callq 0x31b0
jmp 0x3724
movq 0x388d(%rip), %rdi      # 0x6fb8
leaq 0x196c(%rip), %rsi      # 0x509e
callq 0x31a0
movq %rax, (%rsp)
jmp 0x373d
movq (%rsp), %rdi
movq 0x3850(%rip), %rsi      # 0x6f98
callq 0x31b0
jmp 0x374f
movq 0x387a(%rip), %rdi      # 0x6fd0
callq 0x3210
jmp 0x375d
movl $0x0, 0x164(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x3e90
leaq 0x148(%rsp), %rdi
callq 0x3ed0
movl 0x164(%rsp), %eax
addq $0x168, %rsp            # imm = 0x168
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x37b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x3e90
leaq 0x148(%rsp), %rdi
callq 0x3ed0
movq 0x60(%rsp), %rdi
callq 0x32a0
nopl (%rax)
// File: tobias93[P]piano/./Audio.hpp
// Function: AudioPlayer::AudioPlayer()
AudioPlayer()
    {
        if ( dac.getDeviceCount() < 1 ) {
            throw std::runtime_error("No audio devices found.");
        }

        RtAudio::StreamParameters parameters;
        parameters.deviceId = dac.getDefaultOutputDevice();
        parameters.nChannels = 1;
        parameters.firstChannel = 0;


    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
callq 0x3200
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x3a30
movq 0x10(%rsp), %rdi
movq $0x0, 0x18(%rdi)
callq 0x4970
cmpl $0x1, %eax
jae 0x39e6
movl $0x10, %edi
callq 0x30c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x1758(%rip), %rsi      # 0x50f3
callq 0x3080
jmp 0x39a2
movq 0x8(%rsp), %rdi
movq 0x3642(%rip), %rsi      # 0x6ff0
movq 0x35f3(%rip), %rdx      # 0x6fa8
callq 0x3270
jmp 0x3a29
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x3120
jmp 0x3a15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x3a15
leaq 0x18(%rsp), %rdi
callq 0x49b0
jmp 0x39f2
movq 0x10(%rsp), %rdi
callq 0x49d0
movl %eax, 0x18(%rsp)
movl $0x1, 0x1c(%rsp)
movl $0x0, 0x20(%rsp)
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x30f0
movq 0x28(%rsp), %rdi
callq 0x32a0
nopl (%rax)
// File: tobias93[P]piano/./Midi.hpp
// Function: MidiIn::connect_interactive()
void connect_interactive()
    {
        unsigned int portc = midi_in.getPortCount();
        if (portc == 0)
        {
            throw std::runtime_error("No midi devices found.");
        }
        else if (portc == 1)
        {
            connect(0);
        }
        else 
        {
            std::cout << "Please select a midi device: " << std::endl;
            for (int i=0; i < portc; ++i)
            {
                std::cout << " (" << i << ") " << midi_in.getPortName(i) << std::endl;
            }
            int port=-1;
            while(port < 0 || port >= portc) 
            {
                std::cin >> port;
                std::cin.get();			
            }
            connect(port);          
        }
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x4ac0
movl %eax, 0x6c(%rsp)
cmpl $0x0, 0x6c(%rsp)
jne 0x3c0b
movl $0x10, %edi
callq 0x30c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
leaq 0x153c(%rip), %rsi      # 0x510b
callq 0x3080
jmp 0x3bd6
movq 0x20(%rsp), %rdi
movq 0x340e(%rip), %rsi      # 0x6ff0
movq 0x33bf(%rip), %rdx      # 0x6fa8
callq 0x3270
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x3120
jmp 0x3d65
cmpl $0x1, 0x6c(%rsp)
jne 0x3c23
movq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x4ae0
jmp 0x3d5e
movq 0x338e(%rip), %rdi      # 0x6fb8
leaq 0x14f1(%rip), %rsi      # 0x5122
callq 0x31a0
movq %rax, %rdi
movq 0x3358(%rip), %rsi      # 0x6f98
callq 0x31b0
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x6c(%rsp), %eax
jae 0x3d03
movq 0x3356(%rip), %rdi      # 0x6fb8
leaq 0x14d7(%rip), %rsi      # 0x5140
callq 0x31a0
movq %rax, %rdi
movl 0x58(%rsp), %esi
callq 0x3280
movq %rax, %rdi
leaq 0x14bf(%rip), %rsi      # 0x5143
callq 0x31a0
movq 0x28(%rsp), %rsi
movq %rax, 0x8(%rsp)
movl 0x58(%rsp), %edx
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4bb0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3190
movq %rax, 0x18(%rsp)
jmp 0x3cbc
movq 0x18(%rsp), %rdi
movq 0x32d0(%rip), %rsi      # 0x6f98
callq 0x31b0
jmp 0x3ccf
leaq 0x38(%rsp), %rdi
callq 0x30e0
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x3c4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x30e0
jmp 0x3d65
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movb $0x1, %al
cmpl $0x0, 0x34(%rsp)
movb %al, 0x7(%rsp)
jl 0x3d27
movl 0x34(%rsp), %eax
cmpl 0x6c(%rsp), %eax
setae %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x3d31
jmp 0x3d50
movq 0x3298(%rip), %rdi      # 0x6fd0
leaq 0x34(%rsp), %rsi
callq 0x30d0
movq 0x3287(%rip), %rdi      # 0x6fd0
callq 0x3210
jmp 0x3d0b
movq 0x28(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x4ae0
jmp 0x3d60
addq $0x78, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x32a0
nop
// File: tobias93[P]piano/./Audio.hpp
// Function: AudioPlayer::play()
void play()
    {
        if (source == nullptr) {
            throw std::logic_error("There is no source to play from.");
        }
        source->injectAudioSettings(&settins);

        if (!dac.isStreamOpen()) 
        {
            RtAudio::StreamParameters parameters;
            parameters.deviceId = dac.getDefaultOutputDevice();
            parameters.nChannels = settins.nrChannels;
            parameters.firstChannel = 0;
            dac.openStream(&parameters, NULL, RTAUDIO_FLOAT64, settins.sampleRate, &(settins.bufferFrames), &playFromSource, (void *)source );
        }

        dac.startStream();

    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x18(%rax)
jne 0x3de2
movl $0x10, %edi
callq 0x30c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x28(%rsp)
leaq 0x13ad(%rip), %rsi      # 0x5153
callq 0x3230
jmp 0x3dad
movq 0x28(%rsp), %rdi
movq 0x320f(%rip), %rsi      # 0x6fc8
movq 0x31f0(%rip), %rdx      # 0x6fb0
callq 0x3270
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x3120
jmp 0x3e85
movq 0x30(%rsp), %rsi
movq 0x18(%rsi), %rdi
addq $0x8, %rsi
callq 0x4ce0
movq 0x30(%rsp), %rdi
callq 0x4a10
testb $0x1, %al
jne 0x3e76
leaq 0x38(%rsp), %rdi
callq 0x49b0
movq 0x30(%rsp), %rdi
callq 0x49d0
movq 0x30(%rsp), %rdi
movl %eax, 0x38(%rsp)
movl 0x10(%rdi), %eax
movl %eax, 0x3c(%rsp)
movl $0x0, 0x40(%rsp)
movl 0x8(%rdi), %r8d
movq %rdi, %r9
addq $0x8, %r9
addq $0x4, %r9
movq 0x18(%rdi), %rax
leaq 0x38(%rsp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
movl $0x20, %ecx
leaq -0xa16(%rip), %r10      # 0x3440
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x3070
movq 0x30(%rsp), %rdi
callq 0x4d00
addq $0x58, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x32a0
nop
// File: tobias93[P]piano/./Synth.hpp
// Function: SimpleSynth::fillBuffer(double*, unsigned int)
int fillBuffer(double * buffer, unsigned int nBufferFrames)
        {
            for (int i=0; i < nBufferFrames; ++i) 
            {
                buffer[i] = 0;

                unsigned int t = time_code + i;

                for (int n=0; n<max_concurrency; ++n)
                {
                    Note& note = notes[n];
                    double volume = (double)note.velocity / 256 * getEnvelopeVolume(note, synth, t);
                    double frequency = pow(2, (double)(note.note - 69) / 12) * 441;
                    double a = volume * sin((double)t / audio_settings->sampleRate * frequency * 2 * M_PI);
                    buffer[i] += a;
                }

            }
    
            time_code += nBufferFrames;
            return 0;
        }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x40(%rsp)
movl 0x40(%rsp), %eax
cmpl 0x44(%rsp), %eax
jae 0x447d
movq 0x10(%rsp), %rax
movq 0x48(%rsp), %rcx
movslq 0x40(%rsp), %rdx
xorps %xmm0, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movl 0x18(%rax), %eax
addl 0x40(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
cmpl $0xa, 0x38(%rsp)
jge 0x446b
movq 0x10(%rsp), %rdi
addq $0x1c, %rdi
movslq 0x38(%rsp), %rsi
callq 0x4760
movq 0x10(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
movzbl 0x9(%rsi), %eax
cvtsi2sd %eax, %xmm0
movsd 0xca7(%rip), %xmm1      # 0x5020
mulsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq %rdi, %rdx
addq $0x98, %rdx
movl 0x3c(%rsp), %ecx
callq 0x4790
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movzbl 0x8(%rax), %eax
addl $-0x45, %eax
cvtsi2sd %eax, %xmm1
movsd 0xc69(%rip), %xmm0      # 0x5028
mulsd %xmm0, %xmm1
movsd 0xc4d(%rip), %xmm0      # 0x5018
callq 0x3290
movq 0x10(%rsp), %rax
movsd 0xc53(%rip), %xmm1      # 0x5030
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x3c(%rsp), %ecx
cvtsi2sd %rcx, %xmm0
movq 0x8(%rax), %rax
movl (%rax), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
mulsd 0x20(%rsp), %xmm0
movsd 0xbff(%rip), %xmm1      # 0x5018
mulsd %xmm1, %xmm0
movsd 0xbeb(%rip), %xmm1      # 0x5010
mulsd %xmm1, %xmm0
callq 0x3040
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movq 0x48(%rsp), %rax
movslq 0x40(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x433c
jmp 0x446d
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x4304
movq 0x10(%rsp), %rax
movl 0x44(%rsp), %ecx
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
xorl %eax, %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tobias93[P]piano/./Synth.hpp
// Function: SimpleSynth::noteOn(unsigned char, unsigned char)
void noteOn(unsigned char note, unsigned char velocity)
        {
            std::size_t oldest_note = 0;
            for (std::size_t i=1; i<max_concurrency; ++i) 
            {
                if (notes[oldest_note].pressed != notes[i].pressed) 
                {
                    if (!notes[i].pressed) {
                        oldest_note = i;
                    }
                }
                else if(notes[oldest_note].last_event_time_code > notes[i].last_event_time_code) 
                {
                    oldest_note = i;
                }
            }
            
            notes[oldest_note].last_event_time_code = time_code;
            notes[oldest_note].note = note;
            notes[oldest_note].velocity = velocity;
            notes[oldest_note].pressed = true;

        }

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, 0x30(%rsp)
movb %cl, 0x2f(%rsp)
movb %al, 0x2e(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x1, 0x18(%rsp)
cmpq $0xa, 0x18(%rsp)
jae 0x45a0
movq 0x10(%rsp), %rdi
addq $0x1c, %rdi
movq 0x20(%rsp), %rsi
callq 0x4760
movq 0x10(%rsp), %rdi
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
addq $0x1c, %rdi
movq 0x18(%rsp), %rsi
callq 0x4760
movq %rax, %rcx
movl 0xc(%rsp), %eax
movb (%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x4546
movq 0x10(%rsp), %rdi
addq $0x1c, %rdi
movq 0x18(%rsp), %rsi
callq 0x4760
testb $0x1, (%rax)
jne 0x4544
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x458b
movq 0x10(%rsp), %rdi
addq $0x1c, %rdi
movq 0x20(%rsp), %rsi
callq 0x4760
movq 0x10(%rsp), %rdi
movl 0x4(%rax), %eax
movl %eax, 0x8(%rsp)
addq $0x1c, %rdi
movq 0x18(%rsp), %rsi
callq 0x4760
movq %rax, %rcx
movl 0x8(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x4589
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x458b
jmp 0x458d
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x44d2
movq 0x10(%rsp), %rdi
movl 0x18(%rdi), %eax
movl %eax, (%rsp)
addq $0x1c, %rdi
movq 0x20(%rsp), %rsi
callq 0x4760
movl (%rsp), %ecx
movq 0x10(%rsp), %rdi
movl %ecx, 0x4(%rax)
movb 0x2f(%rsp), %al
movb %al, 0x6(%rsp)
addq $0x1c, %rdi
movq 0x20(%rsp), %rsi
callq 0x4760
movb 0x6(%rsp), %cl
movq 0x10(%rsp), %rdi
movb %cl, 0x8(%rax)
movb 0x2e(%rsp), %al
movb %al, 0x7(%rsp)
addq $0x1c, %rdi
movq 0x20(%rsp), %rsi
callq 0x4760
movb 0x7(%rsp), %cl
movq 0x10(%rsp), %rdi
movb %cl, 0x9(%rax)
addq $0x1c, %rdi
movq 0x20(%rsp), %rsi
callq 0x4760
movb $0x1, (%rax)
addq $0x38, %rsp
retq
nop
// File: tobias93[P]piano/./Synth.hpp
// Function: SimpleSynth::noteOff(unsigned char)
void noteOff(unsigned char note) 
        {
            for (std::size_t i=0; i<max_concurrency; ++i) 
            {
                if (notes[i].note == note && notes[i].pressed)
                {
                    notes[i].last_event_time_code = time_code;
                    notes[i].pressed = false;
                }
            }	
        }

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0xa, 0x10(%rsp)
jae 0x46d3
movq 0x8(%rsp), %rdi
addq $0x1c, %rdi
movq 0x10(%rsp), %rsi
callq 0x4760
movzbl 0x8(%rax), %eax
movzbl 0x1f(%rsp), %ecx
cmpl %ecx, %eax
jne 0x46be
movq 0x8(%rsp), %rdi
addq $0x1c, %rdi
movq 0x10(%rsp), %rsi
callq 0x4760
testb $0x1, (%rax)
je 0x46be
movq 0x8(%rsp), %rdi
movl 0x18(%rdi), %eax
movl %eax, 0x4(%rsp)
addq $0x1c, %rdi
movq 0x10(%rsp), %rsi
callq 0x4760
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, 0x4(%rax)
addq $0x1c, %rdi
movq 0x10(%rsp), %rsi
callq 0x4760
movb $0x0, (%rax)
jmp 0x46c0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4643
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH01_GettingStarted/examples/item_io.cc
// Function: main
int main()
{
    Sales_item book;

    // read ISBN, number of copies sold, and sales price
    while(std::cin >> book) {
        // write ISBN, number of copies sold, total revenue, and average price
        std::cout << book << std::endl;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1650
movq 0x2a91(%rip), %rdi      # 0x3fe0
leaq -0x38(%rbp), %rsi
callq 0x1320
movq %rax, -0x50(%rbp)
jmp 0x155e
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x10d0
movb %al, -0x51(%rbp)
jmp 0x1576
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x157f
jmp 0x15c0
movq 0x2a4a(%rip), %rdi      # 0x3fd0
leaq -0x38(%rbp), %rsi
callq 0x13d0
movq %rax, -0x60(%rbp)
jmp 0x1595
movq -0x60(%rbp), %rdi
movq 0x2a20(%rip), %rsi      # 0x3fc0
callq 0x10b0
jmp 0x15a7
jmp 0x1548
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1630
jmp 0x15d9
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1630
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1120
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH02_VariablesAndBasicTypes/examples/ref-ex.cc
// Function: main
int main()
{
	int i = 0, &ri = i;  // ri is a reference to i
	// ri is just another name for i; 
	// this statement prints the value of i twice
	std::cout << i << " " << ri << std::endl;

	i = 5; // changing i is reflected through ri as well
	std::cout << i << " " << ri << std::endl;

	ri = 10; // assigning to ri actually assigns to i
	std::cout << i << " " << ri << std::endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %esi
movq 0x2df0(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xe0d(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2db4(%rip), %rsi      # 0x3fc8
callq 0x1050
movl $0x5, -0x8(%rbp)
movl -0x8(%rbp), %esi
movq 0x2dae(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xdcb(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2d72(%rip), %rsi      # 0x3fc8
callq 0x1050
movq -0x10(%rbp), %rax
movl $0xa, (%rax)
movl -0x8(%rbp), %esi
movq 0x2d69(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xd86(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2d2d(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: IlyaSamoylov45[P]MapReduce-Project/main.cpp
// Function: split_input(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
std::vector<std::string> split_input(std::string file, int maps){
  int word_count = count_words(file);
  //if there are more maps than words return an error
  if(maps > word_count){
    std::cout << "More maps than there are words! You gave " << maps << " maps but there are only " << word_count << " words!" << "\n" << std::endl;
    exit(EXIT_FAILURE);
  }

  std::cout << "Total words: " << word_count << std::endl;
  std::vector<std::string> ary = map_words_to_array(file, maps, word_count);
  //print for error checking
  //for (std::vector<std::string>::const_iterator i = ary.begin(); i != ary.end(); i++){
  //  std::cout << *i << '\n';
  //}
  //
  return ary;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4120
movq -0x78(%rbp), %rdi
callq 0x7ef0
movl %eax, -0x6c(%rbp)
jmp 0x6446
leaq -0x38(%rbp), %rdi
callq 0x41f0
movl -0x6c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x64ea
movq 0x39b58(%rip), %rdi     # 0x3ffc0
leaq 0x21cbd(%rip), %rsi     # 0x2812c
callq 0x4340
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x45b0
movq %rax, %rdi
leaq 0x21ccd(%rip), %rsi     # 0x28156
callq 0x4340
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x45b0
movq %rax, %rdi
leaq 0x21ccd(%rip), %rsi     # 0x28170
callq 0x4340
movq %rax, %rdi
leaq 0x21d3a(%rip), %rsi     # 0x281ec
callq 0x4340
movq %rax, %rdi
movq 0x39ae7(%rip), %rsi     # 0x3ffa8
callq 0x4370
movl $0x1, %edi
callq 0x43c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x41f0
jmp 0x6592
movq 0x39acf(%rip), %rdi     # 0x3ffc0
leaq 0x21c80(%rip), %rsi     # 0x28178
callq 0x4340
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x45b0
movq %rax, %rdi
movq 0x39a96(%rip), %rsi     # 0x3ffa8
callq 0x4370
movq -0x90(%rbp), %rsi
movb $0x0, -0x45(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x4120
movq -0x88(%rbp), %rdi
movq -0x98(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x82b0
jmp 0x654d
leaq -0x68(%rbp), %rdi
callq 0x41f0
movb $0x1, -0x45(%rbp)
testb $0x1, -0x45(%rbp)
jne 0x6585
jmp 0x6579
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x41f0
jmp 0x6592
movq -0x88(%rbp), %rdi
callq 0x97e0
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x45c0
nopl (%rax,%rax)
// File: IlyaSamoylov45[P]MapReduce-Project/main.cpp
// Function: map_function_thread(void*)
void *map_function_thread(void* thread) {
	struct ThreadData *curr_thread_data;
	curr_thread_data = (struct ThreadData *) thread;

	std::vector<std::string> words = split_string_by_space(curr_thread_data->line_array);
	std::map<std::string, int> counterMap;

	for(int i = 0; i < words.size(); i++){
	  if(counterMap.count(words[i])){
	    counterMap[words[i]] = counterMap[words[i]] + 1;
	  } else {
	    counterMap[words[i]] = 1;
	  }
	}

	//test output
	curr_thread_data->counter = counterMap;
	std::map<std::string, int> testMap = curr_thread_data->counter;
	for(auto it = testMap.begin(); it != testMap.end(); it++){
	  //std::cout << it->first << " " << it->second << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x4120
movq -0xe0(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x7d80
jmp 0x7601
leaq -0x48(%rbp), %rdi
callq 0x41f0
leaq -0x88(%rbp), %rdi
callq 0x9910
movl $0x0, -0x8c(%rbp)
movslq -0x8c(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9fc0
movq %rax, %rcx
movq -0xe8(%rbp), %rax
cmpq %rcx, %rax
jae 0x7780
movslq -0x8c(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x98f0
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
callq 0x9fe0
movq %rax, -0xf0(%rbp)
jmp 0x7672
movq -0xf0(%rbp), %rax
cmpq $0x0, %rax
je 0x7735
movslq -0x8c(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x98f0
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
callq 0xa040
movq %rax, -0xf8(%rbp)
jmp 0x76ab
movq -0xf8(%rbp), %rax
movl (%rax), %eax
incl %eax
movl %eax, -0x104(%rbp)
movslq -0x8c(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x98f0
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
callq 0xa040
movq %rax, -0x100(%rbp)
jmp 0x76e4
movq -0x100(%rbp), %rax
movl -0x104(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x776a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41f0
jmp 0x7806
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x9870
leaq -0x28(%rbp), %rdi
callq 0x97e0
jmp 0x7806
movslq -0x8c(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x98f0
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
callq 0xa040
movq %rax, -0x110(%rbp)
jmp 0x775d
movq -0x110(%rbp), %rax
movl $0x1, (%rax)
jmp 0x776c
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0x7620
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
leaq -0x88(%rbp), %rsi
callq 0xa120
jmp 0x7796
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
leaq -0xc0(%rbp), %rdi
callq 0x9840
jmp 0x77ac
leaq -0xc0(%rbp), %rdi
callq 0x9cf0
movq %rax, -0xc8(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x9d50
movq %rax, -0xd0(%rbp)
leaq -0xc8(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x9d20
testb $0x1, %al
jne 0x77eb
jmp 0x7804
jmp 0x77ed
leaq -0xc8(%rbp), %rdi
xorl %esi, %esi
callq 0x9d80
movq %rax, -0xd8(%rbp)
jmp 0x77bf
ud2
movq -0x50(%rbp), %rdi
callq 0x45c0
nop
// File: IlyaSamoylov45[P]MapReduce-Project/main.cpp
// Function: assignJobs(int, int)
std::vector<std::vector<int>> assignJobs(int reduces, int maps){
  std::vector<std::vector<int>> result;
  int amount = maps / reduces;
  int leftOver = maps % reduces;
  int counter = 0;

  for(int i = 0; i < reduces; i++){
    std::vector<int> currentReduce;
    for(int j = 0; j < amount; j++){
      currentReduce.push_back(counter);
      counter++;
    }
    result.push_back(currentReduce);
  }
  for(int i = 0; i < leftOver; i++){
    result[i].push_back(counter);
    counter++;
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x9e40
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x78d8
leaq -0x40(%rbp), %rdi
callq 0x9e60
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x78b5
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9e80
jmp 0x7887
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x7870
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9f60
jmp 0x7941
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9ef0
jmp 0x78c4
leaq -0x40(%rbp), %rdi
callq 0x9f60
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7858
movl $0x0, -0x58(%rbp)
movl -0x58(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x7924
movq -0x68(%rbp), %rdi
movslq -0x58(%rbp), %rsi
callq 0x9970
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0x9e80
jmp 0x7902
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x78df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x7941
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x7937
movq -0x68(%rbp), %rdi
callq 0x9de0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x9de0
movq -0x50(%rbp), %rdi
callq 0x45c0
nopw %cs:(%rax,%rax)