LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/Test/main.c
// Function: testQueue
void testQueue()
{
	size_t i, x;
	eaDSQueue queue = NULL;

	if (NULL == (queue = eaDSQueueInit(intCreateAndCopy, free)))
	{
		puts("queue olusmadi!");
		return;
	}

	for(i = 0; i < 13; i++)
	{
		x = (unsigned int) rand() % 50;

		if(EXIT_SUCCESS == eaDSQueueEnqueue(queue, &x))
		{
			printf("Queue'e eleman eklendi : %d \n", (int)x);
		}
		else
		{
			puts("Queue'e eleman eklenemedi!");
		}
	}

	for(i = 0; !eaDSQueueIsEmpty(queue); i++)
	{
		void * data = eaDSQueueDequeue(queue);

		if(NULL != data)
		{
			printf("Queue'den %d. eleman alindi : %d\n", (int)i + 1, *(int *)data);
			free(data);
		}
		else
		{
			printf("Queue'den %d. eleman alma basarisiz\n", (int)i + 1);
		}
	}

	printf("Queue siliniyor.\n");
	eaDSQueueClear(queue);

	puts("********************************************");
	puts("Queue");
	puts("********************************************");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x18(%rbp)
leaq -0x867(%rip), %rdi      # 0x3df0
movq 0x395a(%rip), %rsi      # 0x7fb8
callq 0x2f70
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x4682
leaq 0xed6(%rip), %rdi       # 0x554e
callq 0x1030
jmp 0x47aa
movq $0x0, -0x8(%rbp)
cmpq $0xd, -0x8(%rbp)
jae 0x46ec
callq 0x10c0
movl $0x32, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %eax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3190
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x46d0
movq -0x10(%rbp), %rax
movl %eax, %esi
leaq 0xe97(%rip), %rdi       # 0x555e
movb $0x0, %al
callq 0x1050
jmp 0x46dc
leaq 0xea5(%rip), %rdi       # 0x557c
callq 0x1030
jmp 0x46de
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x468a
movq $0x0, -0x8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30c0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x470b
jmp 0x476f
movq -0x18(%rbp), %rdi
callq 0x30e0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x4748
movq -0x8(%rbp), %rax
movl %eax, %esi
addl $0x1, %esi
movq -0x20(%rbp), %rax
movl (%rax), %edx
leaq 0xe61(%rip), %rdi       # 0x5597
movb $0x0, %al
callq 0x1050
movq -0x20(%rbp), %rdi
callq 0x10d0
jmp 0x475f
movq -0x8(%rbp), %rax
movl %eax, %esi
addl $0x1, %esi
leaq 0xe61(%rip), %rdi       # 0x55b9
movb $0x0, %al
callq 0x1050
jmp 0x4761
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x46f4
leaq 0xe68(%rip), %rdi       # 0x55de
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rdi
callq 0x3090
leaq 0x8e2(%rip), %rdi       # 0x506f
callq 0x1030
leaq 0xe57(%rip), %rdi       # 0x55f0
callq 0x1030
leaq 0x8ca(%rip), %rdi       # 0x506f
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb-map.cpp
// Function: test_int(int)
int test_int(int n)
{
	int i, cnt = 0;
	uint64_t x = 11;
	intmap_t *h = new intmap_t;

	for (i = 0; i < n; ++i) {
		unsigned y = x % (n>>1);
		x = kad_splitmix64(x);
		std::pair<intmap_t::iterator, bool> p = h->insert(std::pair<unsigned, int>(y, i));
		if (p.second == false) h->erase(p.first);
	}
	cnt = h->size();
	delete h;
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movq $0xb, -0x18(%rbp)
movl $0x30, %edi
callq 0x10a0
movq %rax, %rdi
movq %rdi, -0x68(%rbp)
callq 0x1440
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1306
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1350
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
leaq -0x24(%rbp), %rsi
leaq -0x8(%rbp), %rdx
callq 0x14a0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x1460
movb %dl, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movb -0x48(%rbp), %al
movb %al, -0x30(%rbp)
movb -0x30(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x12f6
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
callq 0x14d0
movq %rax, -0x60(%rbp)
jmp 0x12f8
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1262
movq -0x20(%rbp), %rdi
callq 0x1510
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x1337
movq -0x80(%rbp), %rdi
callq 0x1530
movq -0x80(%rbp), %rdi
movl $0x30, %esi
callq 0x10b0
movl -0xc(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_04/squeeze.c
// Function: main
int main(void)
{
  char str1[MAXSTR] = "abcdefg";
  char str2[MAXSTR] = "abcd";

  squeeze(str1, str2);

  printf("%s", str1);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7e0, %rsp            # imm = 0x7E0
movl $0x0, -0x4(%rbp)
leaq -0x3f0(%rbp), %rdi
leaq 0xe90(%rip), %rsi       # 0x2010
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x1050
leaq -0x7e0(%rbp), %rdi
xorl %esi, %esi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x1040
movb $0x61, -0x7e0(%rbp)
movb $0x62, -0x7df(%rbp)
movb $0x63, -0x7de(%rbp)
movb $0x64, -0x7dd(%rbp)
leaq -0x3f0(%rbp), %rdi
leaq -0x7e0(%rbp), %rsi
callq 0x11f0
leaq -0x3f0(%rbp), %rsi
leaq 0x121e(%rip), %rdi      # 0x23f8
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_04/squeeze.c
// Function: squeeze
void squeeze(char str1[], char str2[])
{
  int i, j, k;
  for (k = 0; str2[k] != '\0'; ++k)
  {
    for (i = j = 0; str1[i] != '\0'; ++i)
    {
      if (str1[i] != str2[k])
      {
        str1[j++] = str1[i];
      }
    }

    str1[j] = '\0';
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x129a
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1280
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x1273
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x1275
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1226
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1203
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/eventfd1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	unsigned long long rbuf;
	unsigned long long wbuf;
	int fd = eventfd(0, 0);
	int ret;

	assert(fd >= 0);

	wbuf = 1;

	while (1) {
		do {
			ret = write(fd, &wbuf, sizeof(wbuf));
		} while (ret != sizeof(wbuf) && errno == EINTR);
		assert(ret == sizeof(wbuf));

		do {
			ret = read(fd, &rbuf, sizeof(rbuf));
		} while (ret != sizeof(rbuf) && errno == EINTR);
		assert(ret == sizeof(wbuf));

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %esi, %esi
movl %esi, %edi
callq 0x1270
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x2054
jmp 0x2073
leaq 0x121b(%rip), %rdi      # 0x3276
leaq 0x121c(%rip), %rsi      # 0x327e
movl $0x11, %edx
leaq 0x1221(%rip), %rcx      # 0x328f
callq 0x1120
movq $0x1, -0x20(%rbp)
jmp 0x207d
movl -0x24(%rbp), %edi
leaq -0x20(%rbp), %rsi
movl $0x8, %edx
callq 0x10c0
movl %eax, -0x28(%rbp)
movslq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq $0x8, %rcx
movb %al, -0x29(%rbp)
je 0x20ae
callq 0x1070
cmpl $0x4, (%rax)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x207d
movslq -0x28(%rbp), %rax
cmpq $0x8, %rax
jne 0x20c1
jmp 0x20e0
leaq 0x11fa(%rip), %rdi      # 0x32c2
leaq 0x11af(%rip), %rsi      # 0x327e
movl $0x19, %edx
leaq 0x11b4(%rip), %rcx      # 0x328f
callq 0x1120
jmp 0x20e2
movl -0x24(%rbp), %edi
leaq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0x1160
movl %eax, -0x28(%rbp)
movslq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq $0x8, %rcx
movb %al, -0x2a(%rbp)
je 0x2113
callq 0x1070
cmpl $0x4, (%rax)
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x20e2
movslq -0x28(%rbp), %rax
cmpq $0x8, %rax
jne 0x2126
jmp 0x2145
leaq 0x1195(%rip), %rdi      # 0x32c2
leaq 0x114a(%rip), %rsi      # 0x327e
movl $0x1e, %edx
leaq 0x114f(%rip), %rcx      # 0x328f
callq 0x1120
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x207b
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/ibperfser.c
// Function: main
int
main(int argc, char ** argv)
{
  if (argc < 6) {
    fprintf(stderr, "Usage: %s <ib-port> <host> <port> <depth> <max-unit>\n", argv[0]);
    exit(0);
  }

  struct ib_port * const port = ib_port_create(atoi(argv[1]));
  if (port == NULL) {
    fprintf(stderr, "ib_port_create() failed\n");
    exit(0);
  }

  const char * const host = argv[2];
  const int pn = atoi(argv[3]);
  const u64 depth = strtoull(argv[4], NULL, 10);
  const u64 unit = strtoull(argv[5], NULL, 10);

  struct worker_info wi;
  wi.port = port;
  wi.depth = depth;
  wi.unit = unit;
  struct server * const ser = server_create(host, pn, perf_worker, &wi);
  if (ser == NULL) {
    fprintf(stderr, "server_create() failed\n");
    exit(0);
  }

  server_wait(ser);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x6, -0x8(%rbp)
jge 0x6832
movq 0x1b7d5(%rip), %rax     # 0x21fe8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x147e0(%rip), %rsi     # 0x1b004
movb $0x0, %al
callq 0x65e0
xorl %edi, %edi
callq 0x6150
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x63c0
movslq %eax, %rdi
callq 0x19f40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6871
movq 0x1b78f(%rip), %rax     # 0x21fe8
movq (%rax), %rdi
leaq 0x147d7(%rip), %rsi     # 0x1b03a
movb $0x0, %al
callq 0x65e0
xorl %edi, %edi
callq 0x6150
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x63c0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x6560
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x6560
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
leaq 0x49(%rip), %rdx        # 0x6930
leaq -0x50(%rbp), %rcx
callq 0xd420
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x691a
movq 0x1b6e6(%rip), %rax     # 0x21fe8
movq (%rax), %rdi
leaq 0x14747(%rip), %rsi     # 0x1b053
movb $0x0, %al
callq 0x65e0
xorl %edi, %edi
callq 0x6150
movq -0x58(%rbp), %rdi
callq 0xd7a0
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::Game(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int)
Game::Game(const std::string& title, const int width, const int height)
		: m_title(title),
		m_width(width),
		m_height(height),
		m_nUpdates(0),
		m_score(0)
	{
		m_mainWindow = nullptr;
		m_state = GameState::UNINITIALIZED;
		m_player = new Asteroids::Player();
		m_entities.push_back(m_player);
		m_dimensions[0] = width;
		m_dimensions[1] = height;

		m_timer = new TimeManager;
		m_lastFrameTime = m_timer->GetElapsedTimeInSeconds();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x9680
movq -0x40(%rbp), %rdi
leaq 0xd4ca(%rip), %rax      # 0x10ad8
movq %rax, (%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x8(%rdi)
movl -0x18(%rbp), %eax
movl %eax, 0xc(%rdi)
movl $0x0, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
addq $0x20, %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x30d0
jmp 0x363e
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x60(%rbp)
callq 0x4b60
movq -0x40(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x58(%rbp)
callq 0x4b80
movq -0x40(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x50(%rbp)
callq 0x4ba0
movq -0x40(%rbp), %rax
movq $0x0, 0x40(%rax)
movl $0x0, 0x50(%rax)
movl $0x50, %edi
callq 0x30f0
movq %rax, -0x48(%rbp)
jmp 0x3697
movq -0x48(%rbp), %rdi
callq 0x7200
jmp 0x36a2
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq %rax, %rdi
addq $0x90, %rdi
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x4bc0
jmp 0x36cb
movl -0x14(%rbp), %eax
movl %eax, 0xdb7c(%rip)      # 0x11250
movl -0x18(%rbp), %eax
movl %eax, 0xdb77(%rip)      # 0x11254
movl $0x38, %edi
callq 0x30f0
movq %rax, -0x68(%rbp)
jmp 0x36ed
movq -0x68(%rbp), %rdi
callq 0xa5c0
jmp 0x36f8
movq -0x40(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0xa8(%rax)
movq 0xa8(%rax), %rdi
callq 0xa730
movsd %xmm0, -0x70(%rbp)
jmp 0x371a
movq -0x40(%rbp), %rax
movsd -0x70(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x37a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3780
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x50, %esi
callq 0x30c0
jmp 0x3780
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x38, %esi
callq 0x30c0
movq -0x50(%rbp), %rdi
callq 0x4c00
movq -0x58(%rbp), %rdi
callq 0x4c20
movq -0x60(%rbp), %rdi
callq 0x4c40
movq -0x38(%rbp), %rdi
callq 0x32c0
movq -0x40(%rbp), %rdi
callq 0x96a0
movq -0x20(%rbp), %rdi
callq 0x3270
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::OnExecute()
void Game::OnExecute()
	{
		if (m_state != GameState::INIT_SUCCESSFUL)
		{
			std::cerr << "Game INIT was not successful." << std::endl;
			return;
		}

		m_state = GameState::RUNNING;
		CreateAsteroid(Asteroids::Asteroid::AsteroidSize::BIG, 1);

		SDL_Event event;
		while (m_state == GameState::RUNNING)
		{
			// Input polling
			//
			while (SDL_PollEvent(&event))
			{
				OnEvent(&event);
			}

			//
			OnUpdate();
			OnRender();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x2, 0x50(%rax)
je 0x391e
movq 0xd6ef(%rip), %rdi      # 0x10ff0
leaq 0x77f3(%rip), %rsi      # 0xb0fb
callq 0x3240
movq %rax, %rdi
movq 0xd6c9(%rip), %rsi      # 0x10fe0
callq 0x33c0
jmp 0x3979
movq -0x48(%rbp), %rdi
movl $0x4, 0x50(%rdi)
xorl %esi, %esi
movl $0x1, %edx
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x3980
movq -0x48(%rbp), %rax
cmpl $0x4, 0x50(%rax)
jne 0x3979
jmp 0x3947
leaq -0x40(%rbp), %rdi
callq 0x33e0
cmpl $0x0, %eax
je 0x3965
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
leaq -0x40(%rbp), %rsi
callq *0x10(%rax)
jmp 0x3947
movq -0x48(%rbp), %rdi
callq 0x3bf0
movq -0x48(%rbp), %rdi
callq 0x3d90
jmp 0x393b
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::OnUpdate()
void Game::OnUpdate()
	{
		double startTime = m_timer->GetElapsedTimeInSeconds();

		// Updating the entities
		//
		std::list< Asteroids::Entity* >::iterator ait = m_entities.begin();
		while (ait != m_entities.end())
		{
			(*ait)->Update(DESIRED_FRAME_TIME, m_width, m_height);
			++ait;
		}

		if(m_player)
		{
			if (up)
				m_player->MoveUp();
			if (left)
				m_player->RotateLeft(DESIRED_FRAME_TIME);
			if (right)
				m_player->RotateRight(DESIRED_FRAME_TIME);

			m_player->Update(DESIRED_FRAME_TIME, m_width, m_height);

			// Checking collision between the entities
			//
			CheckCollision();

			// Checking for entities marked as collided or for deletion
			//
			CleanEntities();
		}

		double endTime = m_timer->GetElapsedTimeInSeconds();
		double nextTimeFrame = startTime + DESIRED_FRAME_TIME;

		while (endTime < nextTimeFrame)
		{
			// Spin lock
			endTime = m_timer->GetElapsedTimeInSeconds();
		}

		//double elapsedTime = endTime - startTime;        

		m_lastFrameTime = m_timer->GetElapsedTimeInSeconds();

		m_nUpdates++;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0xa8(%rax), %rdi
callq 0xa730
movq -0x38(%rbp), %rdi
movsd %xmm0, -0x10(%rbp)
addq $0x90, %rdi
callq 0x4dc0
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
addq $0x90, %rdi
callq 0x4df0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4e20
testb $0x1, %al
jne 0x3c50
jmp 0x3c82
leaq -0x18(%rbp), %rdi
callq 0x4e50
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq (%rcx), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
movq (%rdi), %rax
movss 0x73a8(%rip), %xmm0     # 0xb01c
callq *0x8(%rax)
leaq -0x18(%rbp), %rdi
callq 0x5030
jmp 0x3c29
movq -0x38(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x3d11
testb $0x1, 0xd5b5(%rip)      # 0x1124d
je 0x3ca7
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x8740
testb $0x1, 0xd5a0(%rip)      # 0x1124e
je 0x3cc5
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rdi
movss 0x735c(%rip), %xmm0     # 0xb01c
callq 0x87c0
testb $0x1, 0xd583(%rip)      # 0x1124f
je 0x3ce3
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rdi
movss 0x733e(%rip), %xmm0     # 0xb01c
callq 0x8780
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rdi
movl 0x8(%rax), %esi
movl 0xc(%rax), %edx
movq (%rdi), %rax
movss 0x7320(%rip), %xmm0     # 0xb01c
callq *0x8(%rax)
movq -0x38(%rbp), %rdi
callq 0x4670
movq -0x38(%rbp), %rdi
callq 0x4270
movq -0x38(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0xa730
movsd %xmm0, -0x28(%rbp)
movsd 0x7302(%rip), %xmm0     # 0xb030
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3d5f
movq -0x38(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0xa730
movsd %xmm0, -0x28(%rbp)
jmp 0x3d38
movq -0x38(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0xa730
movq -0x38(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::OnRender()
void Game::OnRender()
	{
		glClearColor(0.1f, 0.1f, 0.15f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);

		// Render player
		//
		if (m_player)
			m_player->Render();

		for (std::list< Asteroids::Entity* >::iterator it = m_entities.begin(); it != m_entities.end(); ++it)
		{
			if ((*it)->CouldCollide())
				(*it)->Render();
		}

		SDL_GL_SwapWindow(m_mainWindow);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movss 0x7274(%rip), %xmm1     # 0xb020
movss 0x7270(%rip), %xmm2     # 0xb024
movss 0x7250(%rip), %xmm3     # 0xb00c
movaps %xmm1, %xmm0
callq 0x30e0
movl $0x4000, %edi           # imm = 0x4000
callq 0x3230
movq -0x20(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x3de7
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
callq 0x4dc0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
callq 0x4df0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4e20
testb $0x1, %al
jne 0x3e22
jmp 0x3e58
leaq -0x10(%rbp), %rdi
callq 0x4e50
movq (%rax), %rdi
callq 0x4f20
testb $0x1, %al
jne 0x3e39
jmp 0x3e4b
leaq -0x10(%rbp), %rdi
callq 0x4e50
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x3e4d
leaq -0x10(%rbp), %rdi
callq 0x5030
jmp 0x3dfb
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3180
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::OnInit()
bool Game::OnInit()
	{
		// Init the external dependencies
		//
		bool success = SDLInit() && GlewInit();
		if (!success)
		{
			m_state = GameState::INIT_FAILED;
			return false;
		}

		// Setup the viewport
		//
		SetupViewport();

		// Change game state
		//
		m_state = GameState::INIT_SUCCESSFUL;

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x3ef0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x12(%rbp)
jne 0x3e97
jmp 0x3ea3
movq -0x20(%rbp), %rdi
callq 0x4010
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3ec2
movq -0x20(%rbp), %rax
movl $0x1, 0x50(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x3eda
movq -0x20(%rbp), %rdi
callq 0x4080
movq -0x20(%rbp), %rax
movl $0x2, 0x50(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::SDLInit()
bool Game::SDLInit()
	{
		// Initialize SDL's Video subsystem
		//
		if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
		{
			std::cerr << "Failed to init SDL" << std::endl;
			return false;
		}

		SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
		SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);

		Uint32 flags =  SDL_WINDOW_OPENGL     | 
						SDL_WINDOW_SHOWN      | 
						SDL_WINDOW_RESIZABLE;

		m_mainWindow = SDL_CreateWindow(
			m_title.c_str(),
			SDL_WINDOWPOS_CENTERED,
			SDL_WINDOWPOS_CENTERED,
			m_width,
			m_height,
			flags
		);

		if (!m_mainWindow)
		{
			std::cerr << "Failed to create window!" << std::endl;
			SDL_Quit();
			return false;
		}

		m_context = SDL_GL_CreateContext(m_mainWindow);
		SDL_GL_MakeCurrent(m_mainWindow, m_context);

		// Make double buffer interval synced with vertical scanline refresh
		SDL_GL_SetSwapInterval(0);

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0xf231, %edi           # imm = 0xF231
callq 0x3440
cmpl $0x0, %eax
jge 0x3f3e
movq 0xd0d6(%rip), %rdi      # 0x10ff0
leaq 0x720b(%rip), %rsi      # 0xb12c
callq 0x3240
movq %rax, %rdi
movq 0xd0b0(%rip), %rsi      # 0x10fe0
callq 0x33c0
movb $0x0, -0x1(%rbp)
jmp 0x3ffd
movl $0x5, %edi
movl $0x1, %esi
callq 0x33d0
movl $0x6, %edi
movl $0x18, %esi
callq 0x33d0
movq -0x20(%rbp), %rdi
movl $0x26, -0x14(%rbp)
addq $0x20, %rdi
callq 0x30b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movl 0xc(%rax), %r8d
movl -0x14(%rbp), %r9d
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
movl %edx, %esi
callq 0x31c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
cmpq $0x0, 0x40(%rax)
jne 0x3fcd
movq 0xd049(%rip), %rdi      # 0x10ff0
leaq 0x7191(%rip), %rsi      # 0xb13f
callq 0x3240
movq %rax, %rdi
movq 0xd023(%rip), %rsi      # 0x10fe0
callq 0x33c0
callq 0x3170
movb $0x0, -0x1(%rbp)
jmp 0x3ffd
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x32a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
movq 0x40(%rax), %rdi
movq 0x48(%rax), %rsi
callq 0x32b0
xorl %edi, %edi
callq 0x3210
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::GlewInit()
bool Game::GlewInit()
	{
		GLenum err = glewInit();
		if (GLEW_OK != err)
		{
			std::cerr << "Error: " << glewGetErrorString(err) << std::endl;
			return false;
		}

		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x3420
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
je 0x406b
movq 0xcfbe(%rip), %rdi      # 0x10ff0
leaq 0x711f(%rip), %rsi      # 0xb158
callq 0x3240
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0x3130
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x3400
movq %rax, %rdi
movq 0xcf80(%rip), %rsi      # 0x10fe0
callq 0x33c0
movb $0x0, -0x1(%rbp)
jmp 0x406f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::SetupViewport()
void Game::SetupViewport()
	{
		// Defining ortho values
		//
		float halfWidth = m_width * 0.5f;
		float halfHeight = m_height * 0.5f;

		// Set viewport to match window
		//
		glViewport(0, 0, m_width, m_height);

		// Set Mode to GL_PROJECTION
		//
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();

		// Set projection MATRIX to ORTHO
		//
		glOrtho(-halfWidth, halfWidth, -halfHeight, halfHeight, -1, 1);

		// Setting Mode to GL_MODELVIEW
		//
		glMatrixMode(GL_MODELVIEW);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cvtsi2ssl 0x8(%rax), %xmm0
movss 0x6f67(%rip), %xmm1     # 0xb004
mulss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
cvtsi2ssl 0xc(%rax), %xmm0
movss 0x6f51(%rip), %xmm1     # 0xb004
mulss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movl 0x8(%rax), %edx
movl 0xc(%rax), %ecx
xorl %esi, %esi
movl %esi, %edi
callq 0x31b0
movl $0x1701, %edi           # imm = 0x1701
callq 0x30a0
callq 0x3120
movss -0xc(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
cvtss2sd %xmm0, %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movss -0x10(%rbp), %xmm2
movd %xmm2, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm2
cvtss2sd %xmm2, %xmm2
movss -0x10(%rbp), %xmm3
cvtss2sd %xmm3, %xmm3
movsd 0x6f18(%rip), %xmm4     # 0xb038
movsd 0x6f18(%rip), %xmm5     # 0xb040
callq 0x3140
movl $0x1700, %edi           # imm = 0x1700
callq 0x30a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::CreateDebris(Asteroids::Entity*)
void Game::CreateDebris(Asteroids::Entity* entity)
	{
		auto currentAsteroid = dynamic_cast < Asteroids::Asteroid* >(entity);
		if (currentAsteroid != nullptr
			&& currentAsteroid->GetSize() != Asteroids::Asteroid::AsteroidSize::SMALL)
		{
			auto newSize = 
				(currentAsteroid->GetSize() == Asteroids::Asteroid::AsteroidSize::BIG) ? 
					Asteroids::Asteroid::AsteroidSize::MEDIUM : 
					Asteroids::Asteroid::AsteroidSize::SMALL;

			CreateAsteroid(newSize, 2, currentAsteroid->GetX(), currentAsteroid->GetY());
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x41e7
movq -0x28(%rbp), %rdi
leaq 0xc9ff(%rip), %rsi      # 0x10bd0
leaq 0xcb88(%rip), %rdx      # 0x10d60
xorl %eax, %eax
movl %eax, %ecx
callq 0x3350
movq %rax, -0x38(%rbp)
jmp 0x41ef
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x41ef
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4260
movq -0x18(%rbp), %rdi
callq 0xa4d0
cmpl $0x2, %eax
je 0x4260
movq -0x18(%rbp), %rdi
callq 0xa4d0
movl %eax, %edx
movl $0x2, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4d80
movss %xmm0, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4da0
movq -0x30(%rbp), %rdi
movl -0x40(%rbp), %esi
movaps %xmm0, %xmm1
movss -0x3c(%rbp), %xmm0
movl $0x2, %edx
callq 0x3980
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::CheckCollision()
void Game::CheckCollision()
	{
		for (std::list< Asteroids::Asteroid* >::iterator asteroid = m_asteroids.begin(); asteroid != m_asteroids.end(); ++asteroid)
		{
			if ((*asteroid)->CouldCollide() && m_player->CouldCollide())
			{
				if (m_player->DetectCollision((*asteroid)))
				{
					CreateDebris((*asteroid));
				}

				for (std::list< Asteroids::Bullet* >::iterator bullet = m_bullets.begin(); bullet != m_bullets.end(); ++bullet)
				{
					if ((*bullet)->CouldCollide() && (*asteroid)->CouldCollide())
					{
						if ((*asteroid)->DetectCollision((*bullet)))
						{
							UpdateScore(10);
							CreateDebris((*asteroid));
						}
					}
				}
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x60, %rdi
callq 0x4e70
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
callq 0x4ed0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4ea0
testb $0x1, %al
jne 0x46b8
jmp 0x47fc
leaq -0x10(%rbp), %rdi
callq 0x4f00
movq (%rax), %rdi
callq 0x4f20
testb $0x1, %al
jne 0x46d2
jmp 0x47ec
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x4f20
testb $0x1, %al
jne 0x46e8
jmp 0x47ec
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x4f00
movq -0x38(%rbp), %rdi
movq (%rax), %rsi
callq 0x70d0
testb $0x1, %al
jne 0x470f
jmp 0x4724
leaq -0x10(%rbp), %rdi
callq 0x4f00
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
callq 0x41a0
movq -0x30(%rbp), %rdi
addq $0x78, %rdi
callq 0x4f40
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
addq $0x78, %rdi
callq 0x4fa0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4f70
testb $0x1, %al
jne 0x475c
jmp 0x47ea
leaq -0x20(%rbp), %rdi
callq 0x4fd0
movq (%rax), %rdi
callq 0x4f20
testb $0x1, %al
jne 0x4773
jmp 0x47da
leaq -0x10(%rbp), %rdi
callq 0x4f00
movq (%rax), %rdi
callq 0x4f20
testb $0x1, %al
jne 0x478a
jmp 0x47da
leaq -0x10(%rbp), %rdi
callq 0x4f00
movq (%rax), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4fd0
movq -0x40(%rbp), %rdi
movq (%rax), %rsi
callq 0x70d0
testb $0x1, %al
jne 0x47b5
jmp 0x47d8
movq -0x30(%rbp), %rdi
movl $0xa, %esi
callq 0x4610
leaq -0x10(%rbp), %rdi
callq 0x4f00
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
callq 0x41a0
jmp 0x47da
jmp 0x47dc
leaq -0x20(%rbp), %rdi
callq 0x4ff0
jmp 0x4735
jmp 0x47ec
jmp 0x47ee
leaq -0x10(%rbp), %rdi
callq 0x5010
jmp 0x4691
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::OnKeyDown(SDL_KeyboardEvent)
void Game::OnKeyDown(SDL_KeyboardEvent keyBoardEvent)
	{		
		switch (keyBoardEvent.keysym.scancode)
		{
		case SDL_SCANCODE_W:
			up = true;
			break;
		case SDL_SCANCODE_A:
			left = true;
			break;		
		case SDL_SCANCODE_D:
			right = true;
			break;
		default:
			//DO NOTHING
			break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x4, %eax
je 0x48c6
jmp 0x48a9
movl -0xc(%rbp), %eax
subl $0x7, %eax
je 0x48cf
jmp 0x48b3
movl -0xc(%rbp), %eax
subl $0x1a, %eax
jne 0x48d8
jmp 0x48bd
movb $0x1, 0xc989(%rip)      # 0x1124d
jmp 0x48da
movb $0x1, 0xc981(%rip)      # 0x1124e
jmp 0x48da
movb $0x1, 0xc979(%rip)      # 0x1124f
jmp 0x48da
jmp 0x48da
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::OnKeyUp(SDL_KeyboardEvent)
void Game::OnKeyUp(SDL_KeyboardEvent keyBoardEvent)
	{
		switch (keyBoardEvent.keysym.scancode)
		{
		case SDL_SCANCODE_W:
			up = false;
			break;
		case SDL_SCANCODE_A:
			left = false;
			break;
		case SDL_SCANCODE_D:
			right = false;
			break;
		case SDL_SCANCODE_R:
			RespawnPlayer();
			break;
		case SDL_SCANCODE_TAB:
			if (m_player)
			{
				m_player->ChangeShip();
			}
			break;
		case SDL_SCANCODE_SPACE:
			//
			if (m_player)
			{
				CreateBullet();
			}
			break;
		case SDL_SCANCODE_ESCAPE:
			OnExit();
			break;
		default:
			//DO NOTHING
			break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0x10(%rax), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x28, %eax
ja 0x4982
movq -0x10(%rbp), %rax
leaq 0x6734(%rip), %rcx      # 0xb048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, 0xc929(%rip)      # 0x1124d
jmp 0x4984
movb $0x0, 0xc921(%rip)      # 0x1124e
jmp 0x4984
movb $0x0, 0xc919(%rip)      # 0x1124f
jmp 0x4984
movq -0x18(%rbp), %rdi
callq 0x4810
jmp 0x4984
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x495b
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x7290
jmp 0x4984
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x4971
movq -0x18(%rbp), %rdi
callq 0x4140
jmp 0x4984
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
jmp 0x4984
jmp 0x4984
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Entity.cpp
// Function: Asteroids::Entity::Update(float, int, int)
void Entity::Update(float deltaTime, int worldWidth, int worldHeight)
	{
		m_position.x += m_velocity.x * static_cast<float>(deltaTime);
		m_position.y += m_velocity.y * static_cast<float>(deltaTime);

		float halfWidth = (worldWidth / 2.0f);
		float halfHeight = (worldHeight / 2.0f);

		float worldMinX = -halfWidth;
		float worldMaxX =  halfWidth;

		float worldMinY = -halfHeight;
		float worldMaxY =  halfHeight;

		m_position.x = wrap(m_position.x, worldMinX, worldMaxX);
		m_position.y = wrap(m_position.y, worldMinY, worldMaxY);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movss 0x10(%rax), %xmm0
movss -0xc(%rbp), %xmm2
movss 0x8(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x8(%rax)
movss 0x14(%rax), %xmm0
movss -0xc(%rbp), %xmm2
movss 0xc(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xc(%rax)
cvtsi2ssl -0x10(%rbp), %xmm0
movss 0x416c(%rip), %xmm1     # 0xb160
divss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
cvtsi2ssl -0x14(%rbp), %xmm0
movss 0x4156(%rip), %xmm1     # 0xb160
divss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x18(%rbp), %xmm0
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x1c(%rbp), %xmm0
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss 0x8(%rax), %xmm0
movss -0x20(%rbp), %xmm1
movss -0x24(%rbp), %xmm2
callq 0x7180
movq -0x38(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss 0xc(%rax), %xmm0
movss -0x28(%rbp), %xmm1
movss -0x2c(%rbp), %xmm2
callq 0x7180
movq -0x38(%rbp), %rax
movss %xmm0, 0xc(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Entity.cpp
// Function: Asteroids::Entity::DetectCollision(Asteroids::Entity*)
bool Entity::DetectCollision(Entity* entity)
	{
		// TODO: RR: Move this to a library
		// Calculating squared distance
		float radii = (m_radius + entity->m_radius);

		float xdiff = m_position.x - entity->m_position.x;
		float ydiff = m_position.y - entity->m_position.y;

		float squaredDistance = (xdiff * xdiff) + (ydiff * ydiff);

		// Checking for collision
		bool collision = (radii * radii) >= squaredDistance;

		// Setting the actors state
		if (collision)
		{
			m_state = EntityState::State::COLLIDED;
			entity->m_state = EntityState::State::COLLIDED;
		}

		return collision;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movss 0x20(%rax), %xmm0
movq -0x10(%rbp), %rcx
addss 0x20(%rcx), %xmm0
movss %xmm0, -0x14(%rbp)
movss 0x8(%rax), %xmm0
movq -0x10(%rbp), %rcx
subss 0x8(%rcx), %xmm0
movss %xmm0, -0x18(%rbp)
movss 0xc(%rax), %xmm0
movq -0x10(%rbp), %rax
subss 0xc(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x18(%rbp), %xmm2
movss -0x1c(%rbp), %xmm1
mulss -0x1c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x14(%rbp), %xmm0
mulss -0x14(%rbp), %xmm0
ucomiss -0x20(%rbp), %xmm0
setae %al
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
je 0x7170
movq -0x30(%rbp), %rax
movl $0x1, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x1c(%rax)
movb -0x21(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Entity.cpp
// Function: Asteroids::wrap(float, float, float)
inline float wrap(float x, float min, float max)
	{
		if (x < min)
		{
			return max - (min - x);
		}

		if (x > max)
		{
			return min + (x - max);
		}

		return x;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss %xmm2, -0x10(%rbp)
movss -0x8(%rbp), %xmm1
movss -0xc(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x71bc
movss -0x10(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
subss -0x8(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x71eb
movss -0x8(%rbp), %xmm0
ucomiss -0x10(%rbp), %xmm0
jbe 0x71e1
movss -0xc(%rbp), %xmm0
movss -0x8(%rbp), %xmm1
subss -0x10(%rbp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x71eb
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Player.cpp
// Function: Asteroids::Player::Player()
Player::Player()
		: m_angle(0.0f)
		, m_rotation(250)
		, m_currentShip(-1)
	{
		m_mass = 0.5f;
		m_radius = 10.0f;

		// Set model render vertices (default ship)
		//
		ChangeShip();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x6f30
movq -0x20(%rbp), %rdi
leaq 0x99cc(%rip), %rax      # 0x10bf0
movq %rax, (%rdi)
addq $0x28, %rdi
movq %rdi, -0x28(%rbp)
callq 0x8b80
movq -0x20(%rbp), %rdi
movl $0x0, 0x40(%rdi)
movl $0x437a0000, 0x44(%rdi) # imm = 0x437A0000
movl $0xffffffff, 0x4c(%rdi) # imm = 0xFFFFFFFF
movl $0x3f000000, 0x18(%rdi) # imm = 0x3F000000
movl $0x41200000, 0x20(%rdi) # imm = 0x41200000
callq 0x7290
jmp 0x7262
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x5d30
movq -0x10(%rbp), %rdi
callq 0x3270
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Player.cpp
// Function: Asteroids::Player::Update(float, int, int)
void Player::Update(float deltaTime, int worldWidth, int worldHeight)
	{
		float speed = 
			fabs(sqrtf(m_velocity.x * m_velocity.x + m_velocity.y * m_velocity.y));

		if (speed > MAX_VELOCITY)
		{
			m_velocity.x = (m_velocity.x / speed) * MAX_VELOCITY;
			m_velocity.y = (m_velocity.y / speed) * MAX_VELOCITY;
		}

		m_currentSpeed = speed;

		ApplyDrag();

		Entity::Update(deltaTime, worldWidth, worldHeight);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movss 0x10(%rax), %xmm0
movss 0x10(%rax), %xmm2
movss 0x14(%rax), %xmm1
mulss 0x14(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0x3390
cvtss2sd %xmm0, %xmm0
movaps 0x29d5(%rip), %xmm1     # 0xb210
pand %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
movss 0x29a7(%rip), %xmm1     # 0xb1fc
ucomiss %xmm1, %xmm0
jbe 0x8894
movq -0x20(%rbp), %rax
movss 0x10(%rax), %xmm0
divss -0x18(%rbp), %xmm0
movss 0x298c(%rip), %xmm1     # 0xb1fc
mulss %xmm1, %xmm0
movss %xmm0, 0x10(%rax)
movss 0x14(%rax), %xmm0
divss -0x18(%rbp), %xmm0
movss 0x2971(%rip), %xmm1     # 0xb1fc
mulss %xmm1, %xmm0
movss %xmm0, 0x14(%rax)
movq -0x20(%rbp), %rdi
movss -0x18(%rbp), %xmm0
movss %xmm0, 0x48(%rdi)
callq 0x8630
movq -0x20(%rbp), %rdi
movss -0xc(%rbp), %xmm0
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x6f90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Player.cpp
// Function: Asteroids::Player::Render()
void Player::Render()
	{
		glLoadIdentity();
		glTranslatef(m_position.x, m_position.y, 0.0f);
		glRotatef(m_angle, 0.0f, 0.0f, 1.0f);

		glBegin(GL_LINE_LOOP);
		
		std::vector<Engine::Vector2>::iterator it = m_points.begin();
		for ( ;it != m_points.end(); ++it)
		{
			glVertex2f((*it).x, (*it).y);
		}
		
		glEnd();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x3120
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm0
movss 0xc(%rax), %xmm1
xorps %xmm2, %xmm2
callq 0x3160
movq -0x20(%rbp), %rax
movss 0x40(%rax), %xmm0
xorps %xmm2, %xmm2
movss 0x26f9(%rip), %xmm3     # 0xb00c
movaps %xmm2, %xmm1
callq 0x3300
movl $0x2, %edi
callq 0x33b0
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x8bf0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x8c60
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x8c20
testb $0x1, %al
jne 0x895a
jmp 0x898f
leaq -0x10(%rbp), %rdi
callq 0x8c90
movss (%rax), %xmm0
movss %xmm0, -0x24(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x8c90
movss -0x24(%rbp), %xmm0
movss 0x4(%rax), %xmm1
callq 0x3200
leaq -0x10(%rbp), %rdi
callq 0x8cb0
jmp 0x8936
callq 0x3320
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/Player.cpp
// Function: Asteroids::Player::Shoot()
Asteroids::Bullet* Player::Shoot()
	{
		float shootingAngle = m_angle + ANGLE_OFFSET;
		float bulletX = m_points[1].x * cosf(shootingAngle * ( PI / 180 ));
		float bulletY = m_points[1].y * sinf(shootingAngle * ( PI / 180 ));

		float vx = (m_currentSpeed + BULLET_SPEED) * cosf(shootingAngle * (PI / 180));
		float vy = (m_currentSpeed + BULLET_SPEED) * sinf(shootingAngle * (PI / 180));

		Bullet* bullet = new Bullet();

		bullet->Teleport(m_position.x + bulletX, m_position.y + bulletY);
		bullet->ApplyImpulse(Engine::Vector2(vx, vy));

		return bullet;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movss 0x40(%rdi), %xmm0
movss 0x2830(%rip), %xmm1     # 0xb1f4
addss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
addq $0x28, %rdi
movq %rdi, -0x78(%rbp)
movl $0x1, %esi
movq %rsi, -0x70(%rbp)
callq 0x8cd0
movss (%rax), %xmm0
movss %xmm0, -0x68(%rbp)
movss -0xc(%rbp), %xmm0
movss 0x27f7(%rip), %xmm1     # 0xb1f0
movss %xmm1, -0x54(%rbp)
mulss %xmm1, %xmm0
callq 0x3290
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movaps %xmm0, %xmm1
movss -0x68(%rbp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
callq 0x8cd0
movss -0x54(%rbp), %xmm1
movss 0x4(%rax), %xmm0
movss %xmm0, -0x64(%rbp)
movss -0xc(%rbp), %xmm0
mulss %xmm1, %xmm0
callq 0x3050
movq -0x60(%rbp), %rax
movss -0x54(%rbp), %xmm1
movaps %xmm0, %xmm2
movss -0x64(%rbp), %xmm0
mulss %xmm2, %xmm0
movss %xmm0, -0x14(%rbp)
movss 0x48(%rax), %xmm0
movss 0x2797(%rip), %xmm2     # 0xb200
movss %xmm2, -0x58(%rbp)
addss %xmm2, %xmm0
movss %xmm0, -0x50(%rbp)
movss -0xc(%rbp), %xmm0
mulss %xmm1, %xmm0
callq 0x3290
movq -0x60(%rbp), %rax
movss -0x58(%rbp), %xmm2
movss -0x54(%rbp), %xmm1
movaps %xmm0, %xmm3
movss -0x50(%rbp), %xmm0
mulss %xmm3, %xmm0
movss %xmm0, -0x18(%rbp)
movss 0x48(%rax), %xmm0
addss %xmm2, %xmm0
movss %xmm0, -0x4c(%rbp)
movss -0xc(%rbp), %xmm0
mulss %xmm1, %xmm0
callq 0x3050
movaps %xmm0, %xmm1
movss -0x4c(%rbp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movl $0x30, %edi
callq 0x30f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0xa040
jmp 0x8aec
movq -0x60(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movss -0x10(%rbp), %xmm2
movss 0x8(%rax), %xmm0
movss 0xc(%rax), %xmm1
addss %xmm2, %xmm0
movss -0x14(%rbp), %xmm2
addss %xmm2, %xmm1
callq 0x70a0
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
leaq -0x3c(%rbp), %rdi
callq 0x9ba0
movq -0x80(%rbp), %rdi
movsd -0x3c(%rbp), %xmm0
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movq -0x28(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x30, %esi
callq 0x30c0
movq -0x30(%rbp), %rdi
callq 0x3270
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/SDLEvent.cpp
// Function: Engine::SDLEvent::HandleWindowEvents(SDL_Event*)
void SDLEvent::HandleWindowEvents(SDL_Event* event)
	{
		switch (event->window.event)
		{
		case SDL_WINDOWEVENT_ENTER:
			OnMouseFocus();
			break;
		case SDL_WINDOWEVENT_LEAVE:
			OnMouseBlur();
			break;
		case SDL_WINDOWEVENT_FOCUS_GAINED:
			OnInputFocus();
			break;
		case SDL_WINDOWEVENT_FOCUS_LOST:
			OnInputBlur();
			break;
		case SDL_WINDOWEVENT_RESTORED:
			OnRestore();
			break;
		case SDL_WINDOWEVENT_MINIMIZED:
			OnMinimize();
			break;
		case SDL_WINDOWEVENT_RESIZED:
			OnResize(event->window.data1, event->window.data2);
			break;
		case SDL_WINDOWEVENT_CLOSE:
			OnExit();
			break;
		case SDL_WINDOWEVENT_EXPOSED:
			OnExpose();
			break;
		default:
			break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0xc(%rax), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xb, %eax
ja 0x99ff
movq -0x18(%rbp), %rax
leaq 0x18e3(%rip), %rcx      # 0xb250
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
jmp 0x9a01
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
jmp 0x9a01
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x9a01
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x9a01
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x90(%rax)
jmp 0x9a01
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
jmp 0x9a01
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
movq (%rdi), %rax
callq *0x98(%rax)
jmp 0x9a01
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0xa8(%rax)
jmp 0x9a01
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0xa0(%rax)
jmp 0x9a01
jmp 0x9a01
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rroa[P]PUCMM_2D_Asteroids/Asteroids/SDLEvent.cpp
// Function: Engine::SDLEvent::HandleMouseButtonDownEvents(SDL_Event*)
void SDLEvent::HandleMouseButtonDownEvents(SDL_Event* event)
	{
		switch (event->button.button)
		{
		case SDL_BUTTON_LEFT:
			OnLButtonDown(event->button.x, event->button.y);
			break;
		case SDL_BUTTON_RIGHT:
			OnRButtonDown(event->button.x, event->button.y);
			break;
		case SDL_BUTTON_MIDDLE:
			OnMButtonDown(event->button.x, event->button.y);
			break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x9a4e
jmp 0x9a3a
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x9a82
jmp 0x9a44
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x9a68
jmp 0x9a9a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
movq (%rdi), %rax
callq *0x58(%rax)
jmp 0x9a9a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
movq (%rdi), %rax
callq *0x68(%rax)
jmp 0x9a9a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
movq (%rdi), %rax
callq *0x78(%rax)
addq $0x20, %rsp
popq %rbp
retq