LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/bf_search/bf_search.c
// Function: bg_print
void bg_print(bit_group *bg) {
    for (int i = bg->group_number - 1; i >= 0; --i) {
        unsigned int num = *(bg->bits + i);
        int          pos = group_type_size;

        for (int j = 0; j < group_type_size; ++j) {
            buf[j] = '0';
        }
        buf[group_type_size + 1] = '\0';

        while (num) {
            buf[pos--] = (num % 2) + '0';
            num /= 2;
        }

        printf("%d(%s)", i, buf);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x4a04
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movl $0x20, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x20, -0x18(%rbp)
jge 0x49a4
movslq -0x18(%rbp), %rcx
leaq 0x380b(%rip), %rax      # 0x81a0
movb $0x30, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4984
movb $0x0, 0x3816(%rip)      # 0x81c1
cmpl $0x0, -0x10(%rbp)
je 0x49de
movl -0x10(%rbp), %eax
andl $0x1, %eax
addl $0x30, %eax
movb %al, %dl
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0x37cf(%rip), %rax      # 0x81a0
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
shrl %eax
movl %eax, -0x10(%rbp)
jmp 0x49ab
movl -0xc(%rbp), %esi
leaq 0x9a5(%rip), %rdi       # 0x538d
leaq 0x37b1(%rip), %rdx      # 0x81a0
movb $0x0, %al
callq 0x1080
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x495b
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/bf_search/bf_search.c
// Function: bf_init
bloom_filter *bf_init(unsigned int k, unsigned long long m) {
    bloom_filter *bf = mp_new(sizeof(bloom_filter));
    bf->hash_num = k;
    bf->bit_length = m;
    bf->value = bg_init(m);
    return bf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x32a0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x48e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/bf_search/bf_search.c
// Function: hash
unsigned long long hash(int type, char *s, unsigned long long limit) {
    unsigned long long code = 0;
    char *             ptr = s;
    int                param = 1;
    int                p = prime[8 - type];

    while (compare_char(*ptr, '\0') != 0) {
        code = (code + (param * (*ptr)));
        param = (param * p);
        ++ptr;
    }

    code = (code ^ 9999901) % limit;

    return code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movl $0x8, %eax
subl -0x4(%rbp), %eax
movslq %eax, %rcx
leaq 0x944(%rip), %rax       # 0x53e0
movl (%rax,%rcx,4), %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
xorl %esi, %esi
movsbl (%rax), %edi
callq 0x2d50
cmpl $0x0, %eax
je 0x4ae8
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rdx
movsbl (%rdx), %edx
imull %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
imull -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4aa2
movq -0x20(%rbp), %rax
xorq $0x98961d, %rax         # imm = 0x98961D
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/bf_search/bf_search.c
// Function: bf_add
void bf_add(bloom_filter *bf, char *s) {
    for (int i = 0; i < bf->hash_num; ++i) {
        int code = hash(i, s, bf->bit_length);
        // set bg code-th bit to 1
        bg_set(bf->value, code);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x4b65
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x4a60
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0x18(%rbp), %rsi
callq 0x4830
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4b27
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/bf_search/bf_search.c
// Function: bf_exist
boolean bf_exist(bloom_filter *bf, char *s) {
    boolean exist = T;
    for (int i = 0; i < bf->hash_num; ++i) {
        int code = hash(i, s, bf->bit_length);
        // set bg code-th bit to 1
        if (!bg_read_file(bf->value, code)) {
            exist = F;
            break;
        }
    }
    return exist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x515(%rip), %rax       # 0x509c
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x4be6
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x4a60
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4870
cmpl $0x0, %eax
jne 0x4bd9
leaq 0x4ce(%rip), %rax       # 0x50a0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x4be6
jmp 0x4bdb
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4b93
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/mmap1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	while (1) {
		char *c = mmap(NULL, MEMSIZE, PROT_READ|PROT_WRITE,
			       MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
		assert(c != MAP_FAILED);
		munmap(c, MEMSIZE);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %r9d
movl $0x8000000, %esi        # imm = 0x8000000
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x20d0
movq %rax, -0x18(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x18(%rbp)
je 0x2ff5
jmp 0x3014
leaq 0x1292(%rip), %rdi      # 0x428e
leaq 0x129b(%rip), %rsi      # 0x429e
movl $0xf, %edx
leaq 0x129d(%rip), %rcx      # 0x42ac
callq 0x2110
movq -0x18(%rbp), %rdi
movl $0x8000000, %esi        # imm = 0x8000000
callq 0x21c0
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2fc0
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/test_nan.c
// Function: main
int
main(int argc VL_UNUSED, char** argv VL_UNUSED)
{
  VL_PRINTF ("Double   NaN : `%g'\n",   VL_NAN_D     ) ;
  VL_PRINTF ("Double   Inf : `%g'\n",   VL_INFINITY_D) ;
  VL_PRINTF ("Double - Inf : `%g'\n", - VL_INFINITY_D) ;
  VL_PRINTF ("Single   NaN : `%g'\n",   VL_NAN_F     ) ;
  VL_PRINTF ("Single   Inf : `%g'\n",   VL_INFINITY_F) ;
  VL_PRINTF ("Single - Inf : `%g'\n", - VL_INFINITY_F) ;

  VL_PRINTF ("Double: 0.0 <   VL_INFINITY_D: %d\n", 0.0 <   VL_INFINITY_D) ;
  VL_PRINTF ("Double: 0.0 > - VL_INFINITY_D: %d\n", 0.0 > - VL_INFINITY_D) ;

  return 0 ;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
callq 0x1030
movq %rax, %rcx
movsd 0xf63(%rip), %xmm0      # 0x20c8
leaq 0xe98(%rip), %rdi       # 0x2004
movb $0x1, %al
callq *%rcx
callq 0x1030
movq %rax, %rcx
movsd 0xf50(%rip), %xmm0      # 0x20d0
leaq 0xe92(%rip), %rdi       # 0x2019
movb $0x1, %al
callq *%rcx
callq 0x1030
movq %rax, %rcx
movsd 0xf35(%rip), %xmm0      # 0x20d0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rax
movq %rax, %xmm0
leaq 0xe75(%rip), %rdi       # 0x202e
movb $0x1, %al
callq *%rcx
callq 0x1030
movq %rax, %rcx
movss 0xf0b(%rip), %xmm0      # 0x20d8
cvtss2sd %xmm0, %xmm0
leaq 0xe6b(%rip), %rdi       # 0x2043
movb $0x1, %al
callq *%rcx
callq 0x1030
movq %rax, %rcx
movss 0xef0(%rip), %xmm0      # 0x20dc
cvtss2sd %xmm0, %xmm0
leaq 0xe61(%rip), %rdi       # 0x2058
movb $0x1, %al
callq *%rcx
callq 0x1030
movq %rax, %rcx
movss 0xed1(%rip), %xmm0      # 0x20dc
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xe4a(%rip), %rdi       # 0x206d
movb $0x1, %al
callq *%rcx
callq 0x1030
movq %rax, %rcx
movsd 0xe99(%rip), %xmm0      # 0x20d0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %esi
leaq 0xe35(%rip), %rdi       # 0x2082
movb $0x0, %al
callq *%rcx
callq 0x1030
movq %rax, %rcx
movsd 0xe6f(%rip), %xmm0      # 0x20d0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rax
movq %rax, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %esi
leaq 0xe17(%rip), %rdi       # 0x20a5
movb $0x0, %al
callq *%rcx
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/test/testThreadUtil.C
// Function: thread_body(void*)
void thread_body(void* data) {
  void* d = malloc(1024);
  fprintf(stdout, "thread is running\n");
  int t = rand() % 5 + 1;
  usleep(t * 1000000);
  fprintf(stdout, "thread is exiting\n");
  free(d);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x400, %edi            # imm = 0x400
callq 0x10d0
movq %rax, 0x8(%rsp)
movq 0x2d39(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
leaq 0xd6b(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x10f0
callq 0x1050
movl $0x5, %ecx
cltd
idivl %ecx
addl $0x1, %edx
movl %edx, 0x4(%rsp)
imull $0xf4240, 0x4(%rsp), %edi # imm = 0xF4240
callq 0x10e0
movq 0x2d00(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
leaq 0xd45(%rip), %rsi       # 0x2017
movb $0x0, %al
callq 0x10f0
movq 0x8(%rsp), %rdi
callq 0x1090
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/test/testThreadUtil.C
// Function: main
int main(int argc, char* argv[]) {
  int num = 100;
  fprintf(stdout, "main thread running\n");
  thread_t threads[num];
  for (int i = 0; i < num; i++) {
    threads[i] = thread_create(thread_body, NULL, "thread1");
  }

  fprintf(stdout, "main calling thread_run()\n");
  for (int i = 0; i < num; i++) {
    thread_run(threads[i]);
  }

  fprintf(stdout, "main calling thread_join()\n");
  for (int i = 0; i < num; i++) {
    thread_join(threads[i]);
  }

  fprintf(stdout, "main calling thread_destroy()\n");
  for (int i = 0; i < num; i++) {
    thread_destroy(threads[i]);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x64, -0x14(%rbp)
movq 0x2cb4(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
leaq 0xd0c(%rip), %rsi       # 0x202a
xorl %eax, %eax
callq 0x10f0
movl -0x14(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x138c
leaq -0xf2(%rip), %rdi       # 0x1270
xorl %eax, %eax
movl %eax, %esi
leaq 0xcd2(%rip), %rdx       # 0x203f
callq 0x14e0
movq %rax, %rdx
movq -0x40(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1353
movq 0x2c35(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
leaq 0xcaa(%rip), %rsi       # 0x2047
movb $0x0, %al
callq 0x10f0
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x13cf
movq -0x40(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1670
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x13ab
movq 0x2bf2(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
leaq 0xc82(%rip), %rsi       # 0x2062
movb $0x0, %al
callq 0x10f0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1412
movq -0x40(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x16c0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x13ee
movq 0x2baf(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
leaq 0xc5b(%rip), %rsi       # 0x207e
movb $0x0, %al
callq 0x10f0
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1455
movq -0x40(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x16f0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1431
movq -0x20(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/threadutil/src/threadutil.C
// Function: thread_init(void*)
void thread_init(void* data) {
  thread_t thrd = (thread_t)data;

  // The first time we run, we hold up this thread until signalled by run
  pthread_mutex_lock(&thrd->lock);
  if (thrd->run == 0) {
    pthread_cond_wait(&thrd->cond, &thrd->lock);
  }
  pthread_mutex_unlock(&thrd->lock);

  // Actually call this thread's procedure
  thrd->proc(thrd->arg);

  // Now exit
  pthread_exit(NULL);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x1100
movq 0x8(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x14b3
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
callq 0x1120
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x1060
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
xorl %eax, %eax
movl %eax, %edi
callq 0x1140
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/threadutil/src/threadutil.C
// Function: thread_create(void (*)(void*), void*, char*)
thread_t thread_create(thread_proc_t proc, void* arg, char* name) {
  thread_t thrd = (thread_t)malloc(sizeof(thread));

  sprintf(thrd->name, "%s", name);
  thrd->proc = proc;
  thrd->arg = arg;
  thrd->run = 0;
  thrd->waiting = 0;

  if (pthread_cond_init(&thrd->cond, NULL) != 0) {
    fprintf(stderr, "[thread] cond init error\n");
    return NULL;
  }

  if (pthread_mutex_init(&thrd->lock, NULL) != 0) {
    fprintf(stderr, "[thread] mutex init error\n");
    return NULL;
  }

  if (pthread_attr_init(&thrd->attr) != 0) {
    fprintf(stderr, "[thread] attr init error\n");
    return NULL;
  }
  pthread_attr_setdetachstate(&thrd->attr, PTHREAD_CREATE_JOINABLE);

  if (pthread_create(&thrd->threadid, &thrd->attr,
                     (void* (*)(void*))thread_init, thrd) != 0) {
    fprintf(stderr, "[thread] pthread_create error\n");
    return NULL;
  }

  return thrd;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl $0xc0, %edi
callq 0x10d0
movq %rax, (%rsp)
movq (%rsp), %rdi
addq $0xb0, %rdi
movq 0x8(%rsp), %rdx
leaq 0xb85(%rip), %rsi       # 0x209d
movb $0x0, %al
callq 0x1040
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movl $0x0, 0x10(%rax)
movq (%rsp), %rax
movl $0x0, 0x14(%rax)
movq (%rsp), %rdi
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10a0
cmpl $0x0, %eax
je 0x158a
movq 0x2a75(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0xb2b(%rip), %rsi       # 0x20a0
movb $0x0, %al
callq 0x10f0
movq $0x0, 0x20(%rsp)
jmp 0x165e
movq (%rsp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1110
cmpl $0x0, %eax
je 0x15c6
movq 0x2a39(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0xb09(%rip), %rsi       # 0x20ba
movb $0x0, %al
callq 0x10f0
movq $0x0, 0x20(%rsp)
jmp 0x165e
movq (%rsp), %rdi
addq $0x70, %rdi
callq 0x10b0
cmpl $0x0, %eax
je 0x15fb
movq 0x2a01(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0xaec(%rip), %rsi       # 0x20d5
movb $0x0, %al
callq 0x10f0
movq $0x0, 0x20(%rsp)
jmp 0x165e
movq (%rsp), %rdi
addq $0x70, %rdi
xorl %esi, %esi
callq 0x10c0
movq (%rsp), %rdi
addq $0xa8, %rdi
movq (%rsp), %rsi
addq $0x70, %rsi
movq (%rsp), %rcx
leaq -0x1b8(%rip), %rdx      # 0x1470
callq 0x1150
cmpl $0x0, %eax
je 0x1655
movq 0x29a7(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0xaac(%rip), %rsi       # 0x20ef
movb $0x0, %al
callq 0x10f0
movq $0x0, 0x20(%rsp)
jmp 0x165e
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/threadutil/src/threadutil.C
// Function: thread_run(s_thread*)
void thread_run(thread_t thrd) {
  if (thrd == NULL) {
    return;
  }

  // Wake up the specified thread
  pthread_mutex_lock(&thrd->lock);
  thrd->run = 1;
  pthread_cond_signal(&thrd->cond);
  pthread_mutex_unlock(&thrd->lock);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x167e
jmp 0x16b0
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x1100
movq (%rsp), %rax
movl $0x1, 0x10(%rax)
movq (%rsp), %rdi
addq $0x40, %rdi
callq 0x1030
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x1060
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/threadutil/src/threadutil.C
// Function: thread_join(s_thread*)
void thread_join(thread_t thrd) {
  if (thrd == NULL) {
    return;
  }

  // Wait for that thread to exit...
  pthread_join(thrd->threadid, NULL);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x16ce
jmp 0x16e2
movq (%rsp), %rax
movq 0xa8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1070
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/threadutil/src/threadutil.C
// Function: thread_destroy(s_thread*)
void thread_destroy(thread_t thrd) {
  pthread_attr_destroy(&thrd->attr);
  pthread_mutex_destroy(&thrd->lock);
  pthread_cond_destroy(&thrd->cond);
  free(thrd);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x70, %rdi
callq 0x1130
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x1080
movq (%rsp), %rdi
addq $0x40, %rdi
callq 0x1160
movq (%rsp), %rdi
callq 0x1090
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/threadutil/src/threadutil.C
// Function: thread_wait(s_thread*)
void thread_wait(thread_t thrd) {
  // The current thread will block and waiting will be set to 1 to indicate
  // there is a thread waiting to be notified
  pthread_mutex_lock(&thrd->lock);
  thrd->waiting++;
  pthread_cond_wait(&thrd->cond, &thrd->lock);
  pthread_mutex_unlock(&thrd->lock);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x1100
movq (%rsp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movq (%rsp), %rdi
addq $0x40, %rdi
movq (%rsp), %rsi
addq $0x18, %rsi
callq 0x1120
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x1060
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/randyrossi[P]fisher-modem/threadutil/src/threadutil.C
// Function: thread_notify(s_thread*)
void thread_notify(thread_t thrd) {
  // Whatever thread was waiting will be woken up.  If there was no thread
  // waiting, the notification will be lost
  pthread_mutex_lock(&thrd->lock);
  if (thrd->waiting > 0) {
    thrd->waiting--;
    pthread_cond_signal(&thrd->cond);
  }
  pthread_mutex_unlock(&thrd->lock);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x1100
movq (%rsp), %rax
cmpl $0x0, 0x14(%rax)
jle 0x17b6
movq (%rsp), %rax
movl 0x14(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rax)
movq (%rsp), %rdi
addq $0x40, %rdi
callq 0x1030
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x1060
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/jwang11[P]intel_avx_perf/matrix_int16.c
// Function: init
void init(void) {
  srand(time(0));
  for (int i = 0; i < row; i++) {
    for (int j = 0; j < col; j++) {
      mat[i][j] = (int16_t)(rand() % 32);
    }   
  }
  for (int j = 0; j < col; j++) {
    mutiplier[j] = (int16_t)(rand() % 32);
  }
}

// Assembly:
subq $0x18, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x1060
movl %eax, %edi
callq 0x1050
movl $0x0, 0x14(%rsp)
cmpl $0x40, 0x14(%rsp)
jge 0x11fa
movl $0x0, 0x10(%rsp)
cmpl $0x1000, 0x10(%rsp)     # imm = 0x1000
jge 0x11eb
callq 0x1070
movl $0x20, %ecx
cltd
idivl %ecx
movslq 0x14(%rsp), %rcx
leaq 0x2e92(%rip), %rax      # 0x4060
shlq $0xd, %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
movw %dx, (%rax,%rcx,2)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x11ab
jmp 0x11ed
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x119c
movl $0x0, 0xc(%rsp)
cmpl $0x1000, 0xc(%rsp)      # imm = 0x1000
jge 0x1236
callq 0x1070
movl $0x20, %ecx
cltd
idivl %ecx
movslq 0xc(%rsp), %rcx
leaq 0x82e3b(%rip), %rax     # 0x84060
movw %dx, (%rax,%rcx,2)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1202
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jwang11[P]intel_avx_perf/matrix_int16.c
// Function: calc_non
void calc_non(void) {
  for(int j = 0; j < row; j++) {
    int16_t sum = 0;
    int16_t *vec = mat[j];

    for(int i = 0; i < col; i++)
      sum += vec[i] * mutiplier[i];

    result[j] = sum;
  }
}

// Assembly:
movl $0x0, -0x4(%rsp)
cmpl $0x40, -0x4(%rsp)
jge 0x12e3
movw $0x0, -0x6(%rsp)
movslq -0x4(%rsp), %rcx
leaq 0x2dfa(%rip), %rax      # 0x4060
shlq $0xd, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x1000, -0x14(%rsp)    # imm = 0x1000
jge 0x12be
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movswl (%rax,%rcx,2), %ecx
movslq -0x14(%rsp), %rdx
leaq 0x82dc2(%rip), %rax     # 0x84060
movswl (%rax,%rdx,2), %eax
imull %eax, %ecx
movswl -0x6(%rsp), %eax
addl %ecx, %eax
movw %ax, -0x6(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x127a
movw -0x6(%rsp), %dx
movslq -0x4(%rsp), %rcx
leaq 0x84d91(%rip), %rax     # 0x86060
movw %dx, (%rax,%rcx,2)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x1248
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kkanellis[P]matvec-sparse/mmio.c
// Function: mm_read_mtx_crd_size
int mm_read_mtx_crd_size(FILE *f, int *M, int *N, int *nz )
{
    char line[MM_MAX_LINE_LENGTH];
    int num_items_read;

    /* set return null parameter values, in case we exit with errors */
    *M = *N = *nz = 0;

    /* now continue scanning until you reach the end-of-comments */
    do 
    {
        if (fgets(line,MM_MAX_LINE_LENGTH,f) == NULL) 
            return MM_PREMATURE_EOF;
    }while (line[0] == '%');

    /* line[] is either blank or has M,N, nz */
    if (sscanf(line, "%d %d %d", M, N, nz) == 3)
        return 0;
        
    else
    do
    { 
        num_items_read = fscanf(f, "%d %d %d", M, N, nz); 
        if (num_items_read == EOF) return MM_PREMATURE_EOF;
    }
    while (num_items_read != 3);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
leaq -0x430(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x401, %esi            # imm = 0x401
callq 0x10c0
cmpq $0x0, %rax
jne 0x1ac0
movl $0xc, -0x4(%rbp)
jmp 0x1b49
jmp 0x1ac2
movsbl -0x430(%rbp), %eax
cmpl $0x25, %eax
je 0x1a99
leaq -0x430(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x266d(%rip), %rsi      # 0x4155
movb $0x0, %al
callq 0x1120
cmpl $0x3, %eax
jne 0x1afd
movl $0x0, -0x4(%rbp)
jmp 0x1b49
jmp 0x1aff
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x263f(%rip), %rsi      # 0x4155
movb $0x0, %al
callq 0x1060
movl %eax, -0x434(%rbp)
cmpl $-0x1, -0x434(%rbp)
jne 0x1b35
movl $0xc, -0x4(%rbp)
jmp 0x1b49
jmp 0x1b37
cmpl $0x3, -0x434(%rbp)
jne 0x1aff
jmp 0x1b42
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kkanellis[P]matvec-sparse/mmio.c
// Function: mm_is_valid
int mm_is_valid(MM_typecode matcode)
{
    if (!mm_is_matrix(matcode)) return 0;
    if (mm_is_dense(matcode) && mm_is_pattern(matcode)) return 0;
    if (mm_is_real(matcode) && mm_is_hermitian(matcode)) return 0;
    if (mm_is_pattern(matcode) && (mm_is_hermitian(matcode) || 
                mm_is_skew(matcode))) return 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4d, %eax
je 0x1b7d
movl $0x0, -0x4(%rbp)
jmp 0x1bfa
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x41, %eax
jne 0x1ba0
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x50, %eax
jne 0x1ba0
movl $0x0, -0x4(%rbp)
jmp 0x1bfa
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x52, %eax
jne 0x1bc3
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x48, %eax
jne 0x1bc3
movl $0x0, -0x4(%rbp)
jmp 0x1bfa
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x50, %eax
jne 0x1bf3
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x48, %eax
je 0x1bea
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x4b, %eax
jne 0x1bf3
movl $0x0, -0x4(%rbp)
jmp 0x1bfa
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kkanellis[P]matvec-sparse/mmio.c
// Function: mm_read_mtx_array_size
int mm_read_mtx_array_size(FILE *f, int *M, int *N)
{
    char line[MM_MAX_LINE_LENGTH];
    int num_items_read;
    /* set return null parameter values, in case we exit with errors */
    *M = *N = 0;
	
    /* now continue scanning until you reach the end-of-comments */
    do 
    {
        if (fgets(line,MM_MAX_LINE_LENGTH,f) == NULL) 
            return MM_PREMATURE_EOF;
    }while (line[0] == '%');

    /* line[] is either blank or has M,N, nz */
    if (sscanf(line, "%d %d", M, N) == 2)
        return 0;
        
    else /* we have a blank line */
    do
    { 
        num_items_read = fscanf(f, "%d %d", M, N); 
        if (num_items_read == EOF) return MM_PREMATURE_EOF;
    }
    while (num_items_read != 2);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
leaq -0x430(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x401, %esi            # imm = 0x401
callq 0x10c0
cmpq $0x0, %rax
jne 0x1ca2
movl $0xc, -0x4(%rbp)
jmp 0x1d23
jmp 0x1ca4
movsbl -0x430(%rbp), %eax
cmpl $0x25, %eax
je 0x1c7b
leaq -0x430(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x2492(%rip), %rsi      # 0x4158
movb $0x0, %al
callq 0x1120
cmpl $0x2, %eax
jne 0x1cdb
movl $0x0, -0x4(%rbp)
jmp 0x1d23
jmp 0x1cdd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x2468(%rip), %rsi      # 0x4158
movb $0x0, %al
callq 0x1060
movl %eax, -0x434(%rbp)
cmpl $-0x1, -0x434(%rbp)
jne 0x1d0f
movl $0xc, -0x4(%rbp)
jmp 0x1d23
jmp 0x1d11
cmpl $0x2, -0x434(%rbp)
jne 0x1cdd
jmp 0x1d1c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kkanellis[P]matvec-sparse/mmio.c
// Function: mm_read_mtx_crd_entry
int mm_read_mtx_crd_entry(FILE *f, int *I, int *J,
        double *real, double *imag, MM_typecode matcode)
{
    if (mm_is_complex(matcode))
    {
            if (fscanf(f, "%d %d %lg %lg", I, J, real, imag)
                != 4) return MM_PREMATURE_EOF;
    }
    else if (mm_is_real(matcode))
    {
            if (fscanf(f, "%d %d %lg\n", I, J, real)
                != 3) return MM_PREMATURE_EOF;

    }

    else if (mm_is_pattern(matcode))
    {
            if (fscanf(f, "%d %d", I, J) != 2) return MM_PREMATURE_EOF;
    }
    else
        return MM_UNSUPPORTED_TYPE;

    return 0;
        
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x43, %eax
jne 0x1fa2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
leaq 0x21d6(%rip), %rsi      # 0x415e
movb $0x0, %al
callq 0x1060
cmpl $0x4, %eax
je 0x1fa0
movl $0xc, -0x4(%rbp)
jmp 0x2028
jmp 0x2021
movq -0x38(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x52, %eax
jne 0x1fdd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x2106(%rip), %rsi      # 0x40cc
movb $0x0, %al
callq 0x1060
cmpl $0x3, %eax
je 0x1fdb
movl $0xc, -0x4(%rbp)
jmp 0x2028
jmp 0x201f
movq -0x38(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x50, %eax
jne 0x2014
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x215b(%rip), %rsi      # 0x4158
movb $0x0, %al
callq 0x1060
cmpl $0x2, %eax
je 0x2012
movl $0xc, -0x4(%rbp)
jmp 0x2028
jmp 0x201d
movl $0xf, -0x4(%rbp)
jmp 0x2028
jmp 0x201f
jmp 0x2021
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kkanellis[P]matvec-sparse/mmio.c
// Function: mm_write_banner
int mm_write_banner(FILE *f, MM_typecode matcode)
{
    char *str = mm_typecode_to_str(matcode);
    int ret_code;

    ret_code = fprintf(f, "%s %s\n", MatrixMarketBanner, str);
    free(str);
    if (ret_code !=2 )
        return MM_COULD_NOT_WRITE_FILE;
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1880
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rcx
leaq 0x1e46(%rip), %rsi      # 0x4172
leaq 0x1db3(%rip), %rdx      # 0x40e6
movb $0x0, %al
callq 0x10f0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
cmpl $0x2, -0x24(%rbp)
je 0x2355
movl $0x11, -0x4(%rbp)
jmp 0x235c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kkanellis[P]matvec-sparse/mmio-wrapper.c
// Function: write_matrix
int write_matrix (const char *filename, const int *i_idx, const int *j_idx, const double *values, int N, int NZ)
{
    FILE* f;
    MM_typecode matcode;

    /* open the file */
    if ( (f = fopen(filename, "w")) == NULL ) {
        fprintf(stderr, "Cannot open '%s'\n", filename);
        return 1;
    }

    /* init and set proper flags for matrix */
    mm_initialize_typecode(&matcode);
    mm_set_matrix(&matcode);
    mm_set_real(&matcode);
    mm_set_sparse(&matcode);

    /* write banner and matrix size info */
    mm_write_banner(f, matcode);
    mm_write_mtx_crd_size(f, N, N, NZ);

    /* write matrix elements */
    for (int i = 0; i < NZ; i++) {
        fprintf(f, "%d %d %.9lf\n", i_idx[i] + 1, j_idx[i] + 1, values[i]);
    }

    /* close the file */
    if ( fclose(f) != 0 ) {
        fprintf(stderr, "Cannot close file (fil:'%s')\n", filename);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x18b5(%rip), %rsi      # 0x4180
callq 0x1130
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x2902
movq 0x3717(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x18bd(%rip), %rsi      # 0x41ac
movb $0x0, %al
callq 0x10f0
movl $0x1, -0x4(%rbp)
jmp 0x29c3
movb $0x20, -0x3a(%rbp)
movb $0x20, -0x3b(%rbp)
movb $0x20, -0x3c(%rbp)
movb $0x47, -0x39(%rbp)
movb $0x4d, -0x3c(%rbp)
movb $0x52, -0x3a(%rbp)
movb $0x43, -0x3b(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x2300
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x1c00
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x2992
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movq -0x20(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
addl $0x1, %ecx
movq -0x28(%rbp), %rax
movslq -0x40(%rbp), %rsi
movsd (%rax,%rsi,8), %xmm0
leaq 0x1917(%rip), %rsi      # 0x4297
movb $0x1, %al
callq 0x10f0
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x2944
movq -0x38(%rbp), %rdi
callq 0x1080
cmpl $0x0, %eax
je 0x29bc
movq 0x3651(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x18c4(%rip), %rsi      # 0x4279
movb $0x0, %al
callq 0x10f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kkanellis[P]matvec-sparse/util.c
// Function: random_vec
void random_vec (double *v, int N, int limit)
{
    /* fill v with random doubles */
    limit--;
    srand( 410 );
    for (int i = 0; i < N; i++) {
        v[i] = ((double)rand()) / (((double)RAND_MAX) / limit) + \
               ((double)rand()) / ((double)RAND_MAX);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
movl $0x19a, %edi            # imm = 0x19A
callq 0x10b0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2e7d
callq 0x1160
cvtsi2sd %eax, %xmm0
cvtsi2sdl -0x10(%rbp), %xmm2
movsd 0x1476(%rip), %xmm1     # 0x42b0
divsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x1160
movsd -0x20(%rbp), %xmm0
cvtsi2sd %eax, %xmm1
movsd 0x1453(%rip), %xmm2     # 0x42b0
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2e1c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kkanellis[P]matvec-sparse/util.c
// Function: malloc_or_exit
void * malloc_or_exit(size_t size) {
    void * ptr = malloc( size );
    if ( !ptr ) {
        fprintf(stderr, "malloc: failed to allocate memory\n");
        exit(EXIT_FAILURE);
    }
    return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2ed2
movq 0x3141(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x13f7(%rip), %rsi      # 0x42b8
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x1150
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kkanellis[P]matvec-sparse/util.c
// Function: calloc_or_exit
void * calloc_or_exit(size_t nmemb, size_t size) {
    void * ptr = calloc(nmemb, size);
    if ( !ptr ) {
        fprintf(stderr, "calloc: failed to allocate memory\n");
        exit(EXIT_FAILURE);
    }
    return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2f2a
movq 0x30e9(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x13c2(%rip), %rsi      # 0x42db
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x1150
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kkanellis[P]matvec-sparse/stopwatch.c
// Function: _sw_stop
void __sw_stop(const int id, double * value) {
    clock_gettime(CLOCK_MONOTONIC_RAW, sw + N_STOPWATCHES);
    *value += (
        (double) ((sw[N_STOPWATCHES].tv_nsec - sw[id].tv_nsec) / 1000000.0 )+
        (double) ((sw[N_STOPWATCHES].tv_sec - sw[id].tv_sec) * 1000.0)
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x4, %edi
leaq 0x3115(%rip), %rsi      # 0x60e0
addq $0x50, %rsi
callq 0x1070
movq 0x315d(%rip), %rax      # 0x6138
movslq -0x4(%rbp), %rdx
leaq 0x30fa(%rip), %rcx      # 0x60e0
shlq $0x4, %rdx
addq %rdx, %rcx
subq 0x8(%rcx), %rax
cvtsi2sd %rax, %xmm1
movsd 0x130a(%rip), %xmm0     # 0x4308
divsd %xmm0, %xmm1
movq 0x3127(%rip), %rax      # 0x6130
movslq -0x4(%rbp), %rdx
leaq 0x30cc(%rip), %rcx      # 0x60e0
shlq $0x4, %rdx
addq %rdx, %rcx
subq (%rcx), %rax
cvtsi2sd %rax, %xmm0
movsd 0x12d5(%rip), %xmm2     # 0x4300
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_3/exercise_3_05/itob.c
// Function: main
int main(void)
{
  char s[MAXLEN];

  int n = -2;

  itob(n, s, 16);

  printf("%s", s);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl $0xfffffffe, -0x74(%rbp) # imm = 0xFFFFFFFE
movl -0x74(%rbp), %edi
leaq -0x70(%rbp), %rsi
movl $0x10, %edx
callq 0x11a0
leaq -0x70(%rbp), %rsi
leaq 0xe7f(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_3/exercise_3_05/itob.c
// Function: itob
void itob(int n, char s[], int b)
{
  int i = 0, sign = n;

  do
  {
    s[i++] = itoc(abs(n) % b);
    n /= b;
  } while (n);

  switch (b)
  {
  case 2:
    s[i++] = 'b';
    s[i++] = '0';
    break;

  case 16:
    s[i++] = 'x';
    s[i++] = '0';
    break;
  }

  if (sign < 0)
  {
    s[i++] = '-';
  }

  s[i] = '\0';

  int s_len = strlen(s);
  str_reverse(s, 0, s_len - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cltd
idivl -0x14(%rbp)
movl %edx, %edi
callq 0x12c0
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %ecx
movl -0x4(%rbp), %eax
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x11bf
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x2, %eax
je 0x1214
jmp 0x120a
movl -0x24(%rbp), %eax
subl $0x10, %eax
je 0x1242
jmp 0x126e
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movb $0x62, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movb $0x30, (%rax,%rcx)
jmp 0x126e
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movb $0x78, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movb $0x30, (%rax,%rcx)
cmpl $0x0, -0x1c(%rbp)
jge 0x128a
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movb $0x2d, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x1030
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x12f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/main.c
// Function: main
int main(int argc,char **argv)
{
	if (SDL_Init(0) < 0)
	{
		// no logging available because init failed
		fprintf(stderr,"SDL_Init failed: %s\n",SDL_GetError());
		SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR,APP_TITLE,SDL_GetError(),NULL);
		return EXIT_FAILURE;
	}
#ifdef NDEBUG
	SDL_LogSetAllPriority(SDL_LOG_PRIORITY_INFO);
#else
	SDL_LogSetAllPriority(SDL_LOG_PRIORITY_DEBUG);
#endif
	EMU_Init();
	CORE_Start();
	SDL_Quit();
	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %edi, %edi
callq 0x10b0
cmpl $0x0, %eax
jge 0x1460
movq 0x324bc7(%rip), %rax    # 0x325fe0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x1080
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x320bd1(%rip), %rsi    # 0x322004
movb $0x0, %al
callq 0x10e0
callq 0x1080
movq %rax, %rdx
movl $0x10, %edi
leaq 0x320bcb(%rip), %rsi    # 0x322019
xorl %eax, %eax
movl %eax, %ecx
callq 0x1090
movl $0x1, -0x4(%rbp)
jmp 0x1480
movl $0x2, %edi
callq 0x1040
callq 0x31a6f0
callq 0x3211b0
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/bios.c
// Function: BIOS_StrCat
uint32_t BIOS_StrCat(uint32_t dest,uint32_t src)
{
	uint32_t len;
	uint32_t i = 0;
	uint8_t c = 1;
	for (len = 0;EMU_ReadU8(dest + len);len++);
	while (c)
	{
		EMU_Write8(dest + len + i,c = EMU_ReadU8(src + i));
		i++;
	}
	return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x4(%rbp), %edi
addl -0xc(%rbp), %edi
callq 0x31a7b0
cmpb $0x0, %al
je 0x3193fc
jmp 0x3193f1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3193e0
jmp 0x3193fe
cmpb $0x0, -0x11(%rbp)
je 0x319434
movl -0x4(%rbp), %eax
addl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %edi
addl -0x10(%rbp), %edi
callq 0x31a7b0
movl -0x18(%rbp), %edi
movb %al, -0x11(%rbp)
movzbl %al, %esi
callq 0x31bdc0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3193fe
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/bios.c
// Function: BIOS_StrCmp
int32_t BIOS_StrCmp(uint32_t str1,uint32_t str2)
{
	uint32_t i = 0;
	while (1)
	{
		int8_t c1 = EMU_ReadS8(str1 + i);
		int8_t c2 = EMU_ReadS8(str2 + i);
		if (c1 != c2)
			return c1 - c2;
		else if (c1 == 0)
			return 0;
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x8(%rbp), %edi
addl -0x10(%rbp), %edi
callq 0x31a790
movb %al, -0x11(%rbp)
movl -0xc(%rbp), %edi
addl -0x10(%rbp), %edi
callq 0x31a790
movb %al, -0x12(%rbp)
movsbl -0x11(%rbp), %eax
movsbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
je 0x31948c
movsbl -0x11(%rbp), %eax
movsbl -0x12(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x3194ab
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0x31949e
movl $0x0, -0x4(%rbp)
jmp 0x3194ab
jmp 0x3194a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x319455
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/bios.c
// Function: BIOS_StrNCmp
int32_t BIOS_StrNCmp(uint32_t str1,uint32_t str2,uint32_t maxlen)
{
	uint32_t i = 0;
	while (i < maxlen)
	{
		int8_t c1 = EMU_ReadS8(str1 + i);
		int8_t c2 = EMU_ReadS8(str2 + i);
		if (c1 != c2)
			return c1 - c2;
		else if (c1 == 0)
			return 0;
		i++;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x319536
movl -0x8(%rbp), %edi
addl -0x14(%rbp), %edi
callq 0x31a790
movb %al, -0x15(%rbp)
movl -0xc(%rbp), %edi
addl -0x14(%rbp), %edi
callq 0x31a790
movb %al, -0x16(%rbp)
movsbl -0x15(%rbp), %eax
movsbl -0x16(%rbp), %ecx
cmpl %ecx, %eax
je 0x319517
movsbl -0x15(%rbp), %eax
movsbl -0x16(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x31953d
movsbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jne 0x319529
movl $0x0, -0x4(%rbp)
jmp 0x31953d
jmp 0x31952b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3194d8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/bios.c
// Function: BIOS_StrCpy
uint32_t BIOS_StrCpy(uint32_t dest,uint32_t src)
{
	uint32_t i = 0;
	uint8_t c = 1;
	while (c)
	{
		EMU_Write8(dest + i,c = EMU_ReadU8(src + i));
		i++;
	}
	return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movb $0x1, -0xd(%rbp)
cmpb $0x0, -0xd(%rbp)
je 0x31959c
movl -0x4(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %edi
addl -0xc(%rbp), %edi
callq 0x31a7b0
movl -0x14(%rbp), %edi
movb %al, -0xd(%rbp)
movzbl %al, %esi
callq 0x31bdc0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x319569
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/bios.c
// Function: BIOS_BCopy
uint32_t BIOS_BCopy(uint32_t src,uint32_t dest,int32_t len)
{
	if (!src)
		return src;
	if (len < 0)
		return src;
	for (uint32_t i = 0;i < len;i++)
		EMU_Write8(dest + i,EMU_ReadU8(src + i));
	return src;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x31960f
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x31965c
cmpl $0x0, -0x10(%rbp)
jge 0x31961d
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x31965c
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x319656
movl -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %edi
addl -0x14(%rbp), %edi
callq 0x31a7b0
movl -0x18(%rbp), %edi
movzbl %al, %esi
callq 0x31bdc0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x319624
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/bios.c
// Function: BIOS_MemSet
uint32_t BIOS_MemSet(uint32_t dest,uint8_t value,int32_t len)
{
	if (!dest)
		return dest;
	if (len < 0)
		return dest;
	for (uint32_t i = 0;i < len;i++)
		EMU_Write8(dest + i,value);
	return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movl %edi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x3196c2
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3196ff
cmpl $0x0, -0x10(%rbp)
jge 0x3196d0
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3196ff
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x3196f9
movl -0x8(%rbp), %edi
addl -0x14(%rbp), %edi
movzbl -0x9(%rbp), %esi
callq 0x31bdc0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3196d7
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/bios.c
// Function: BIOS_MemCpy
uint32_t BIOS_MemCpy(uint32_t dest,uint32_t src,int32_t len)
{
	if (!dest)
		return dest;
	if (len < 0)
		return dest;
	for (uint32_t i = 0;i < len;i++)
		EMU_Write8(dest + i,EMU_ReadU8(src + i));
	return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x31972f
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x31977c
cmpl $0x0, -0x10(%rbp)
jge 0x31973d
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x31977c
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x319776
movl -0x8(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %edi
addl -0x14(%rbp), %edi
callq 0x31a7b0
movl -0x18(%rbp), %edi
movzbl %al, %esi
callq 0x31bdc0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x319744
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)