LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(unsigned char *m, unsigned long long *mlen,
                        unsigned char *nsec,
                        const unsigned char *c, unsigned long long clen,
                        const unsigned char *ad, unsigned long long adlen,
                        const unsigned char *npub,
                        const unsigned char *k)
{
    poet_ctx_t ctx;
    (void)nsec;
    
    if (clen < CRYPTO_ABYTES) {
        return -1;
    }

    keysetup(&ctx, k);
    
    if (npub) {
        unsigned char *header = malloc((size_t)(adlen + CRYPTO_NPUBBYTES));
        memcpy(header, ad, adlen);
        memcpy(header + adlen, npub, CRYPTO_NPUBBYTES);
        process_header(&ctx, header, adlen + CRYPTO_NPUBBYTES);
        free(header);
    } else {
        process_header(&ctx, ad, adlen);
    }
    
    unsigned char tag[CRYPTO_ABYTES];
    memcpy(tag, c + (clen - CRYPTO_ABYTES), CRYPTO_ABYTES);
    return decrypt_final(&ctx, c, clen - CRYPTO_ABYTES, tag, m, mlen);
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x10, %r8
jb 0x1398
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %r9, %r13
movq %r8, %r14
movq %rcx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq 0x2d0(%rsp), %rsi
movq 0x2c0(%rsp), %rbp
leaq 0x20(%rsp), %rdi
callq 0x10d0
cmpq $0x0, 0x2c8(%rsp)
je 0x134d
addq $0x10, %rbp
movq %rbp, %rdi
callq 0x1030
movq %rbx, 0x8(%rsp)
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
movq 0x2c0(%rsp), %rdx
callq 0x10c0
movq 0x2c8(%rsp), %rax
vmovups (%rax), %xmm0
movq 0x2c0(%rsp), %rax
vmovups %xmm0, (%rbx,%rax)
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x10b0
movq %rbx, %rdi
movq 0x8(%rsp), %rbx
callq 0x1070
jmp 0x135d
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x10b0
vmovups -0x10(%r12,%r14), %xmm0
addq $-0x10, %r14
leaq 0x10(%rsp), %rcx
vmovaps %xmm0, (%rcx)
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %r8
movq %rbx, %r9
callq 0x1080
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: keysetup_encrypt_only
void keysetup_encrypt_only(poet_ctx_t *ctx, const unsigned char key[KEYLEN])
{
    AES_KEY expanded_key;
    __m128i sk = loadu(key);
    __m128i k = zero;
    ctx->l = one;
    __m128i k_axu = two;

    aes_expand_key(sk, expanded_key);
    aes_encrypt_3blocks_single_key(k, ctx->l, k_axu, expanded_key);

    aes_expand_key(k, ctx->aes_enc);
    aes_expand_key(k_axu, ctx->aes_axu);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
vmovups (%rsi), %xmm0
vmovaps 0x2125(%rip), %xmm1     # 0x4020
vmovaps %xmm1, 0x210(%rdi)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x2080
vmovdqa (%r14), %xmm0
vpxor 0x2103(%rip), %xmm0, %xmm1 # 0x4020
vmovdqa %xmm1, 0x210(%rbx)
vpxor 0x2103(%rip), %xmm0, %xmm2 # 0x4030
vmovdqa 0x10(%r14), %xmm3
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm3, %xmm1, %xmm1
vmovdqa %xmm1, 0x210(%rbx)
vaesenc %xmm3, %xmm2, %xmm2
vmovdqa 0x20(%r14), %xmm3
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm3, %xmm1, %xmm1
vmovdqa %xmm1, 0x210(%rbx)
vaesenc %xmm3, %xmm2, %xmm2
vmovdqa 0x30(%r14), %xmm3
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm3, %xmm1, %xmm1
vmovdqa %xmm1, 0x210(%rbx)
vmovdqa 0x40(%r14), %xmm4
vaesenc %xmm3, %xmm2, %xmm2
vaesenc %xmm4, %xmm0, %xmm0
vaesenc %xmm4, %xmm1, %xmm1
vmovdqa %xmm1, 0x210(%rbx)
vaesenc %xmm4, %xmm2, %xmm2
vmovdqa 0x50(%r14), %xmm3
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm3, %xmm1, %xmm1
vmovdqa %xmm1, 0x210(%rbx)
vaesenc %xmm3, %xmm2, %xmm2
vmovdqa 0x60(%r14), %xmm3
vaesenc %xmm3, %xmm1, %xmm1
vmovdqa %xmm1, 0x210(%rbx)
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm3, %xmm2, %xmm2
vmovdqa 0x70(%r14), %xmm3
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm3, %xmm1, %xmm1
vmovdqa %xmm1, 0x210(%rbx)
vaesenc %xmm3, %xmm2, %xmm2
vmovdqa 0x80(%r14), %xmm3
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm3, %xmm1, %xmm1
vmovdqa %xmm1, 0x210(%rbx)
vaesenc %xmm3, %xmm2, %xmm2
vmovdqa 0x90(%r14), %xmm3
vaesenc %xmm3, %xmm0, %xmm0
vaesenc %xmm3, %xmm1, %xmm1
vmovdqa %xmm1, 0x210(%rbx)
vmovdqa 0xa0(%r14), %xmm4
vaesenc %xmm3, %xmm2, %xmm2
vaesenclast %xmm4, %xmm0, %xmm0
vaesenclast %xmm4, %xmm1, %xmm1
vmovdqa %xmm1, 0x210(%rbx)
vaesenclast %xmm4, %xmm2, %xmm1
vmovdqa %xmm1, (%rsp)
movq %rbx, %rdi
callq 0x2080
addq $0x160, %rbx            # imm = 0x160
vmovaps (%rsp), %xmm0
movq %rbx, %rdi
addq $0xc8, %rsp
popq %rbx
popq %r14
jmp 0x2080
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/aes128poetv2aes128ni/ref/poet.c
// Function: bit_revert
static unsigned long long reverse_bits(unsigned long long x)
{
    x = ((x & UINT64_C(0x0f0f0f0f0f0f0f0f)) << 4)
        | ((x & UINT64_C(0xf0f0f0f0f0f0f0f0)) >> 4);
    x = ((x & UINT64_C(0x3333333333333333)) << 2)
        | ((x & UINT64_C(0xcccccccccccccccc)) >> 2);
    x = ((x & UINT64_C(0x5555555555555555)) << 1)
        | ((x & UINT64_C(0xaaaaaaaaaaaaaaaa)) >> 1);
    return x;
}

// Assembly:
vpsllq $0x4, %xmm0, %xmm1
vpsrlq $0x4, %xmm0, %xmm0
vpternlogq $0xd8, 0x9b6(%rip){1to2}, %xmm1, %xmm0 # 0x4040
vpsllq $0x2, %xmm0, %xmm1
vpsrlq $0x2, %xmm0, %xmm0
vpternlogq $0xd8, 0x9a9(%rip){1to2}, %xmm1, %xmm0 # 0x4048
vpaddq %xmm0, %xmm0, %xmm1
vpsrlq $0x1, %xmm0, %xmm0
vpternlogq $0xd8, 0x99d(%rip){1to2}, %xmm1, %xmm0 # 0x4050
retq
// File: /workspace/github_c_makefile_star2_O1/motet-a[P]libforks/examples/communication.c
// Function: main
int main() {
  libforks_ServerConn conn;
  assert(libforks_start(&conn) == libforks_OK);

  int socket_fd;

  assert(libforks_fork(
    conn,
    NULL, // pid_ptr
    &socket_fd, // socket_fd_ptr
    NULL, // exit_fd_ptr
    child_main
  ) == libforks_OK);

  puts("Type text and press enter");
  puts("Exit with Ctrl+D");

  while (true) {
    char c;
    int read_res = read(STDIN_FILENO, &c, 1);
    if (read_res == 0) { // EOF
      break;
    }
    assert(read_res == 1);

    assert(write(socket_fd, &c, 1) == 1);
    assert(read(socket_fd, &c, 1) == 1);
    assert(write(STDOUT_FILENO, &c, 1) == 1);
  }

  assert(libforks_stop(conn) == libforks_OK);
  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rdi
callq 0x18db
testl %eax, %eax
jne 0x1466
movq 0x8(%rsp), %rdi
leaq 0x184(%rip), %r8        # 0x14c3
leaq 0x4(%rsp), %rdx
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x232f
testl %eax, %eax
jne 0x1485
leaq 0x1d3a(%rip), %rdi      # 0x3096
callq 0x1080
leaq 0x1d48(%rip), %rdi      # 0x30b0
callq 0x1080
leaq 0x3(%rsp), %rbx
movl $0x1, %edx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x1110
cmpl $0x1, %eax
jne 0x13eb
movl 0x4(%rsp), %edi
movl $0x1, %edx
movq %rbx, %rsi
callq 0x10a0
cmpq $0x1, %rax
jne 0x1409
movl 0x4(%rsp), %edi
movl $0x1, %edx
movq %rbx, %rsi
callq 0x1110
cmpq $0x1, %rax
jne 0x1428
movl $0x1, %edx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x10a0
cmpq $0x1, %rax
je 0x1372
leaq 0x1d35(%rip), %rdi      # 0x3108
leaq 0x1c4f(%rip), %rsi      # 0x3029
leaq 0x1c61(%rip), %rcx      # 0x3042
movl $0x35, %edx
callq 0x10d0
testl %eax, %eax
jne 0x1447
movq 0x8(%rsp), %rdi
callq 0x24ea
testl %eax, %eax
jne 0x14a4
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x1cbf(%rip), %rdi      # 0x30cf
leaq 0x1c12(%rip), %rsi      # 0x3029
leaq 0x1c24(%rip), %rcx      # 0x3042
movl $0x33, %edx
callq 0x10d0
leaq 0x1cbd(%rip), %rdi      # 0x30ec
leaq 0x1bf3(%rip), %rsi      # 0x3029
leaq 0x1c05(%rip), %rcx      # 0x3042
movl $0x34, %edx
callq 0x10d0
leaq 0x1c73(%rip), %rdi      # 0x30c1
leaq 0x1bd4(%rip), %rsi      # 0x3029
leaq 0x1be6(%rip), %rcx      # 0x3042
movl $0x31, %edx
callq 0x10d0
leaq 0x1b97(%rip), %rdi      # 0x3004
leaq 0x1bb5(%rip), %rsi      # 0x3029
leaq 0x1bc7(%rip), %rcx      # 0x3042
movl $0x1c, %edx
callq 0x10d0
leaq 0x1bc1(%rip), %rdi      # 0x304d
leaq 0x1b96(%rip), %rsi      # 0x3029
leaq 0x1ba8(%rip), %rcx      # 0x3042
movl $0x26, %edx
callq 0x10d0
leaq 0x1c7e(%rip), %rdi      # 0x3129
leaq 0x1b77(%rip), %rsi      # 0x3029
leaq 0x1b89(%rip), %rcx      # 0x3042
movl $0x38, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/motet-a[P]libforks/examples/communication.c
// Function: child_main
static void child_main(libforks_ServerConn conn, int socket_fd) {
  (void)conn;

  // We could use seccomp(2) (on Linux) or pledge(2) (on OpenBSD) here.

  while (true) {
    char c;
    assert(read(socket_fd, &c, 1) == 1);
    c = toupper(c);
    assert(write(socket_fd, &c, 1) == 1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
movl %ebx, %edi
callq 0x1110
cmpq $0x1, %rax
jne 0x152c
callq 0x1030
movq %rax, %r14
leaq 0xf(%rsp), %r15
movq (%r14), %rax
movsbq 0xf(%rsp), %rcx
movb (%rax,%rcx,4), %al
movb %al, 0xf(%rsp)
movl $0x1, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x10a0
cmpq $0x1, %rax
jne 0x154b
movl $0x1, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x1110
cmpq $0x1, %rax
je 0x14f2
leaq 0x1bb9(%rip), %rdi      # 0x30ec
leaq 0x1aef(%rip), %rsi      # 0x3029
leaq 0x1c0b(%rip), %rcx      # 0x314c
movl $0x14, %edx
callq 0x10d0
leaq 0x1b7d(%rip), %rdi      # 0x30cf
leaq 0x1ad0(%rip), %rsi      # 0x3029
leaq 0x1bec(%rip), %rcx      # 0x314c
movl $0x16, %edx
callq 0x10d0
nop
// File: /workspace/github_c_makefile_star2_O1/dxwc[P]sfeed/sfeed_twtxt.c
// Function: main
int
main(int argc, char *argv[])
{
	FILE *fp;
	char *name;
	int i;

	if (pledge(argc == 1 ? "stdio" : "stdio rpath", NULL) == -1)
		err(1, "pledge");

	if (argc == 1) {
		printfeed(stdin, "");
	} else {
		for (i = 1; i < argc; i++) {
			if (!(fp = fopen(argv[i], "r")))
				err(1, "fopen: %s", argv[i]);
			name = ((name = strrchr(argv[i], '/'))) ? name + 1 : argv[i];
			printfeed(fp, name);
			if (ferror(fp))
				err(1, "ferror: %s", argv[i]);
			fclose(fp);
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jne 0x1304
movq 0x2ced(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0xd47(%rip), %rsi       # 0x2044
callq 0x13a5
jmp 0x136c
jle 0x136c
movq %rsi, %rbx
movl %edi, %r13d
movl $0x1, %ebp
leaq 0xcec(%rip), %r14       # 0x2004
movq (%rbx,%rbp,8), %rdi
movq %r14, %rsi
callq 0x1180
movq (%rbx,%rbp,8), %r12
testq %rax, %rax
je 0x137d
movq %rax, %r15
movq %r12, %rdi
movl $0x2f, %esi
callq 0x10c0
leaq 0x1(%rax), %rsi
testq %rax, %rax
cmoveq %r12, %rsi
movq %r15, %rdi
callq 0x13a5
movq %r15, %rdi
callq 0x1060
testl %eax, %eax
jne 0x138e
movq %r15, %rdi
callq 0x1070
incq %rbp
cmpq %rbp, %r13
jne 0x1318
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc82(%rip), %rsi       # 0x2006
movl $0x1, %edi
movq %r12, %rdx
jmp 0x139e
movq (%rbx,%rbp,8), %rdx
leaq 0xc77(%rip), %rsi       # 0x2010
movl $0x1, %edi
xorl %eax, %eax
callq 0x1170
// File: /workspace/github_c_makefile_star2_O1/dxwc[P]sfeed/sfeed_twtxt.c
// Function: printfeed
static void
printfeed(FILE *fp, const char *feedname)
{
	char *fields[FieldLast];
	struct tm *tm;
	time_t parsedtime;
	ssize_t linelen;

	while ((linelen = getline(&line, &linesize, fp)) > 0) {
		if (line[linelen - 1] == '\n')
			line[--linelen] = '\0';
		if (!parseline(line, fields))
			break;

		parsedtime = 0;
		if (strtotime(fields[FieldUnixTimestamp], &parsedtime))
			continue;
		if (!(tm = gmtime(&parsedtime)))
			err(1, "localtime");

		fprintf(stdout, "%04d-%02d-%02dT%02d:%02d:%02dZ\t",
		        tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
		        tm->tm_hour, tm->tm_min, tm->tm_sec);
		if (feedname[0])
			printf("[%s] ", feedname);
		fputs(fields[FieldTitle], stdout);
		if (fields[FieldLink][0]) {
			fputs(": ", stdout);
			fputs(fields[FieldLink], stdout);
		}
		putchar('\n');
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2d48(%rip), %rdi      # 0x4108
leaq 0x2d49(%rip), %rsi      # 0x4110
movq %r14, %rdx
callq 0x11b0
testq %rax, %rax
jle 0x14ef
leaq 0x8(%rsp), %r12
movq 0x2bf4(%rip), %r15      # 0x3fd8
leaq 0x2d1d(%rip), %rbp      # 0x4108
leaq 0x2d1e(%rip), %r13      # 0x4110
movq 0x2d0f(%rip), %rcx      # 0x4108
cmpb $0xa, -0x1(%rcx,%rax)
jne 0x1405
movb $0x0, -0x1(%rcx,%rax)
movq 0x2cfc(%rip), %rdi      # 0x4108
leaq 0x10(%rsp), %rsi
callq 0x1a2f
testq %rax, %rax
je 0x14ef
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x1ab4
testl %eax, %eax
jne 0x14d8
movq %r12, %rdi
callq 0x1190
testq %rax, %rax
je 0x14fe
movq (%r15), %rdi
movl 0x14(%rax), %edx
movl $0x76c, %ecx            # imm = 0x76C
addl %ecx, %edx
movl 0x10(%rax), %ecx
incl %ecx
movl 0xc(%rax), %r8d
movl 0x8(%rax), %r9d
movl (%rax), %r10d
movl 0x4(%rax), %r11d
leaq 0xbaf(%rip), %rsi       # 0x2025
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x1130
addq $0x10, %rsp
cmpb $0x0, (%rbx)
je 0x149b
leaq 0xbb4(%rip), %rdi       # 0x2045
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10a0
movq 0x18(%rsp), %rdi
movq (%r15), %rsi
callq 0x10d0
movq 0x20(%rsp), %rax
cmpb $0x0, (%rax)
je 0x14ce
movq (%r15), %rsi
leaq 0xb8f(%rip), %rdi       # 0x204b
callq 0x10d0
movq 0x20(%rsp), %rdi
movq (%r15), %rsi
callq 0x10d0
movl $0xa, %edi
callq 0x1030
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x11b0
testq %rax, %rax
jg 0x13f2
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb16(%rip), %rsi       # 0x201b
movl $0x1, %edi
xorl %eax, %eax
callq 0x1170
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/OhYee[P]computer_application_programming_experiment/utils/compare/test/test_compare.c
// Function: main
int main() {
    boolean       pass = T;
    testcase_char test_char[] = {
        {arg1: 'a', arg2: 'b', want_res: -1},
        {arg1: 'a', arg2: 'a', want_res: 0},
        {arg1: '0', arg2: '0', want_res: 0},
        {arg1: '1', arg2: '!', want_res: 1},
    };
    testcase_string test_string[] = {
        {arg1: "Hello", arg2: "Hello", want_res: 0},
        {arg1: "Hi", arg2: "Hi0", want_res: -1},
        {arg1: "Hi", arg2: "Hi\0", want_res: 0},
        {arg1: "ABC\0B", arg2: "ABC\0A", want_res: 0},
    };

    for (int i = 0; i < sizeof(test_char) / sizeof(testcase_char); ++i) {
        testcase_char *tc = &test_char[i];
        int            got = compare_char(tc->arg1, tc->arg2);
        if (got * tc->want_res < 0 || (tc->want_res == 0 && got != 0)) {
            pass = F;
            print_err("Check error at compare_char('%c','%c')=%d, got=%d\n",
                      tc->arg1, tc->arg2, tc->want_res,
                      compare_char(tc->arg1, tc->arg2));
        }
    }

    for (int i = 0; i < sizeof(test_string) / sizeof(testcase_string); ++i) {
        testcase_string *tc = &test_string[i];
        if (compare_string(tc->arg1, tc->arg2) != tc->want_res) {
            pass = F;
            print_err("Check error at compare_string('%s','%s')=%d\n", tc->arg1,
                      tc->arg2, tc->want_res);
        }
    }

    if (pass) {
        print_ok("All testcase passed\n");
        return 0;
    } else {
        print_err("Some error\n");
        return 1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xbbe(%rip), %rax       # 0x2004
movl (%rax), %r12d
leaq 0xbb8(%rip), %rax       # 0x2008
movl (%rax), %eax
movl %eax, 0x4(%rsp)
leaq 0xc23(%rip), %rbx       # 0x2080
xorl %r13d, %r13d
movsbl (%rbx,%r13,8), %ebp
movsbl 0x1(%rbx,%r13,8), %r14d
movl %ebp, %edi
movl %r14d, %esi
callq 0x13d0
movl 0x4(%rbx,%r13,8), %r15d
movl %r15d, %ecx
imull %eax, %ecx
testl %ecx, %ecx
js 0x1493
testl %r15d, %r15d
setne %cl
testl %eax, %eax
sete %al
orb %cl, %al
jne 0x14bb
movl %ebp, %edi
movl %r14d, %esi
callq 0x13d0
leaq 0xc09(%rip), %rdi       # 0x20ad
movl %ebp, %esi
movl %r14d, %edx
movl %r15d, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x1070
movl 0x4(%rsp), %r12d
incq %r13
cmpq $0x4, %r13
jne 0x1460
leaq 0xb3d(%rip), %rax       # 0x2008
movl (%rax), %ebp
movl $0x10, %r13d
leaq 0x28a6(%rip), %rbx      # 0x3d80
movq -0x10(%r13,%rbx), %r14
movq -0x8(%r13,%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x13dc
movl (%r13,%rbx), %ecx
cmpl %ecx, %eax
je 0x150f
leaq 0xbe1(%rip), %rdi       # 0x20e0
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1070
movl %ebp, %r12d
addq $0x18, %r13
cmpq $0x70, %r13
jne 0x14da
testl %r12d, %r12d
je 0x1530
leaq 0xbe8(%rip), %rdi       # 0x210d
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1301
jmp 0x1543
leaq 0xbeb(%rip), %rdi       # 0x2122
xorl %eax, %eax
callq 0x1070
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/baileywjohnson[P]mpi-matrix-mult/print-matrix.c
// Function: main
int main(int argc, char *argv[]){

	int rows, columns;
	double *A;
	char *in;

	int c;
	if(argc != 3){
		printf("USAGE: print-matrix -i <your filename>\n");
		exit(1);
	}
	while((c = getopt(argc, argv, "i:")) != -1){
		switch(c){
			case 'i':
				in = optarg;	
				break;
			case '?':
				exit(1);
				break;
			default:
				break;
		}
	}

	read_matrix(in, &rows, &columns, &A);
	print_matrix(rows, columns, A);
	free(A);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x3, %edi
jne 0x1298
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xddb(%rip), %r15       # 0x2004
movq 0x2dc0(%rip), %r12      # 0x3ff0
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1070
cmpl $-0x1, %eax
je 0x1254
cmpl $0x69, %eax
je 0x124e
cmpl $0x3f, %eax
jne 0x1230
jmp 0x12a4
movq (%r12), %r14
jmp 0x1230
leaq 0x4(%rsp), %rbx
movq %rsp, %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x1453
movl (%rbx), %edi
movl (%r15), %esi
movq (%r12), %rdx
callq 0x1351
movq (%r12), %rdi
callq 0x10a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd68(%rip), %rdi       # 0x2007
callq 0x1040
movl $0x1, %edi
callq 0x1050
nop
// File: /workspace/github_c_makefile_star2_O1/baileywjohnson[P]mpi-matrix-mult/functions.c
// Function: make_matrix
void make_matrix(int m, int n, int l, int u, double **A){
	*A = malloc(sizeof(double) * (n * m));
	int i;
	srand(time(0));
	for(i = 0; i < (n * m); i++){
		double myRand = rand()/(1.0 + RAND_MAX);
		int range = u - l + 1;
		double myRand_scaled = (myRand * range) + l;
		(*A)[i] = myRand_scaled;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movl %ecx, %r14d
movl %edx, %ebp
movl %edi, %r15d
imull %esi, %r15d
movslq %r15d, %r12
leaq (,%r12,8), %rdi
callq 0x1080
movq %rax, (%rbx)
xorl %edi, %edi
callq 0x1100
movl %eax, %edi
callq 0x10c0
testl %r12d, %r12d
jle 0x1344
subl %ebp, %r14d
incl %r14d
cvtsi2sd %r14d, %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%rsp)
movl %r15d, %r14d
xorl %r15d, %r15d
callq 0x10f0
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0xd08(%rip), %xmm0      # 0x2030
mulsd 0x8(%rsp), %xmm0
addsd (%rsp), %xmm0
movq (%rbx), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x1314
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/baileywjohnson[P]mpi-matrix-mult/functions.c
// Function: print_matrix
void print_matrix(int m, int n, double* A){
	int i, j;
	int index = 0;
	for(i=0; i<m; i++){
		for(j=0; j<n; j++){
			printf("%f\t", A[index]);
			index += 1;
		}
		printf("\n");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movl %esi, 0x8(%rsp)
movl %edi, 0xc(%rsp)
testl %edi, %edi
jle 0x13c3
movl 0x8(%rsp), %r12d
xorl %r13d, %r13d
leaq 0xcb9(%rip), %r15       # 0x2038
xorl %ebx, %ebx
cmpl $0x0, 0x8(%rsp)
jle 0x13b1
movslq %r13d, %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %r14
xorl %ebp, %ebp
movsd (%r14,%rbp,8), %xmm0
movq %r15, %rdi
movb $0x1, %al
callq 0x1030
incq %rbp
cmpl %ebp, %r12d
jne 0x1396
addl %ebp, %r13d
movl $0xa, %edi
callq 0x1060
incl %ebx
cmpl 0xc(%rsp), %ebx
jne 0x1381
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/baileywjohnson[P]mpi-matrix-mult/functions.c
// Function: write_matrix
void write_matrix(char* out, int m, int n, double* A){
	FILE *fp = fopen(out, "wb");
	//write m to first location in file
	fwrite(&m, sizeof(int), 1, fp);
	//write n to second location in file
	fwrite(&n, sizeof(int), 1, fp);
	//write n integers from A into it ALL IN ONE fwrite()
	fwrite(A, sizeof(double), (n * m), fp);
	fclose(fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
leaq 0x4(%rsp), %r15
movl %esi, (%r15)
movq %rsp, %r12
movl %edx, (%r12)
leaq 0xc49(%rip), %rsi       # 0x203c
callq 0x1090
movq %rax, %r14
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rax, %rcx
callq 0x10e0
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rcx
callq 0x10e0
movslq (%r12), %rax
movslq (%r15), %rdx
imulq %rax, %rdx
movl $0x8, %esi
movq %rbx, %rdi
movq %r14, %rcx
callq 0x10e0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10d0
// File: /workspace/github_c_makefile_star2_O1/baileywjohnson[P]mpi-matrix-mult/functions.c
// Function: read_matrix
void read_matrix(char* out, int *m, int *n, double** A){
	int rows, columns;
	FILE *fp = fopen(out, "rb");
	//fread() once to get the rows out of the file
	fread(&rows, sizeof(int), 1, fp);
	*m = rows;
	//fread() again to get the columns out of the file
	fread(&columns, sizeof(int), 1, fp);
	*n = columns;
	//malloc a buffer of the right size to hold the rest of the remaining data
	*A = malloc(sizeof(double) * (rows * columns));
	//fread() the remaining data into buffer
	fread(*A, sizeof(double), (rows * columns), fp);
	fclose(fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
leaq 0xbd1(%rip), %rsi       # 0x203f
callq 0x1090
movq %rax, %r14
leaq 0x4(%rsp), %r13
movl $0x4, %esi
movl $0x1, %edx
movq %r13, %rdi
movq %rax, %rcx
callq 0x10b0
movl (%r13), %ebp
movl %ebp, (%r12)
movq %rsp, %r12
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rcx
callq 0x10b0
movl (%r12), %eax
movl %eax, (%r15)
imull %ebp, %eax
movslq %eax, %r15
leaq (,%r15,8), %rdi
callq 0x1080
movq %rax, (%rbx)
movl $0x8, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x10b0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10d0
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/semind.c
// Function: semind_error
static void semind_error(int status, int errnum, const char *fmt, ...)
{
	va_list ap;
	semind_print_progname();

	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);

	if (errnum > 0)
		fprintf(stderr, ": %s", strerror(errnum));

	fprintf(stderr, "\n");

	if (status)
		exit(status);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %ebx
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xf5ce
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x589e3(%rip), %r15     # 0x67fb8
movq (%r15), %rdi
movq 0x5e0e1(%rip), %rdx     # 0x6d6c0
leaq 0x36807(%rip), %rsi     # 0x45ded
xorl %eax, %eax
callq 0xf4b0
movq 0x5f0e4(%rip), %rdx     # 0x6e6d8
testq %rdx, %rdx
je 0xf60a
movq (%r15), %rdi
leaq 0x367ea(%rip), %rsi     # 0x45ded
xorl %eax, %eax
callq 0xf4b0
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rdx)
movq (%r15), %rdi
movq %r14, %rsi
callq 0xf1f0
testl %ebp, %ebp
jg 0xf65b
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0xf200
testl %ebx, %ebx
jne 0xf67b
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %r14
movl %ebp, %edi
callq 0xf2b0
leaq 0x3612e(%rip), %rsi     # 0x4579a
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xf4b0
jmp 0xf63e
pushq $0x1
popq %rdi
callq 0xf120
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/semind.c
// Function: parse_cmdline_add
static void parse_cmdline_add(int argc, char **argv)
{
	static const struct option long_options[] = {
		{ "include-local-syms", no_argument, NULL, 1 },
		{ "verbose", no_argument, NULL, 'v' },
		{ "help", no_argument, NULL, 'h' },
		{ NULL }
	};
	int c;

	opterr = 0;

	while ((c = getopt_long(argc, argv, "+vh", long_options, NULL)) != -1) {
		switch (c) {
			case 1:
				semind_include_local_syms = 1;
				break;
			case 'v':
				semind_verbose++;
				break;
			case 'h':
				show_help_add(0);
			case '?':
				goto done;
		}
	}
done:
	if (optind == argc) {
		message("more arguments required");
		show_usage();
	}

	// enforce tabstop
	tabstop = 1;

	// step back since sparse_initialize will ignore argv[0].
	optind--;

	sparse_initialize(argc - optind, argv + optind, &semind_filelist);
	dissect_show_all_symbols = 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
movq 0x57abf(%rip), %rax     # 0x67f48
movl $0x0, (%rax)
leaq 0x34c89(%rip), %r15     # 0x4511f
leaq 0x4f323(%rip), %r12     # 0x5f7c0
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0xf350
cmpl $0x3e, %eax
jle 0x104c2
cmpl $0x76, %eax
jne 0x104d0
incl 0x5e22c(%rip)           # 0x6e6ec
jmp 0x1049d
cmpl $0x1, %eax
jne 0x104dc
movb $0x1, 0x5e21a(%rip)     # 0x6e6e8
jmp 0x1049d
cmpl $0x3f, %eax
je 0x104e1
cmpl $0x68, %eax
jne 0x1049d
jmp 0x1052d
cmpl $-0x1, %eax
jne 0x1049d
movq 0x57a48(%rip), %rax     # 0x67f30
cmpl %ebx, (%rax)
je 0x10549
leaq 0x5c10d(%rip), %rcx     # 0x6c600
movl $0x1, %ebp
movl %ebp, (%rcx)
movslq (%rax), %rcx
leaq -0x1(%rcx), %rdx
movl %edx, (%rax)
subl %edx, %ebx
leaq (%r14,%rcx,8), %rsi
addq $-0x8, %rsi
leaq 0x5e1dc(%rip), %rdx     # 0x6e6f0
movl %ebx, %edi
callq 0x138aa
leaq 0x5ec02(%rip), %rax     # 0x6f124
movl %ebp, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x5d18c(%rip), %rsi     # 0x6d6c0
leaq 0x34c00(%rip), %rdi     # 0x4513b
xorl %eax, %eax
callq 0xf050
xorl %edi, %edi
callq 0xf120
leaq 0x34bd3(%rip), %rdx     # 0x45123
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0xf570
callq 0x110dd
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/semind.c
// Function: parse_cmdline_rm
static void parse_cmdline_rm(int argc, char **argv)
{
	static const struct option long_options[] = {
		{ "verbose", no_argument, NULL, 'v' },
		{ "help", no_argument, NULL, 'h' },
		{ NULL }
	};
	int c;

	while ((c = getopt_long(argc, argv, "+vh", long_options, NULL)) != -1) {
		switch (c) {
			case 'v':
				semind_verbose++;
				break;
			case 'h':
				show_help_rm(0);
		}
	}

	if (optind == argc) {
		message("more arguments required");
		show_usage();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
leaq 0x3487d(%rip), %r15     # 0x4511f
leaq 0x4efb7(%rip), %r12     # 0x5f860
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0xf350
cmpl $0x76, %eax
je 0x108cd
cmpl $-0x1, %eax
je 0x108d5
cmpl $0x68, %eax
jne 0x108a9
jmp 0x108ec
incl 0x5de19(%rip)           # 0x6e6ec
jmp 0x108a9
movq 0x57654(%rip), %rax     # 0x67f30
cmpl %ebx, (%rax)
je 0x10908
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x5cdcd(%rip), %rsi     # 0x6d6c0
leaq 0x34ce0(%rip), %rdi     # 0x455da
xorl %eax, %eax
callq 0xf050
xorl %edi, %edi
callq 0xf120
leaq 0x34814(%rip), %rdx     # 0x45123
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0xf570
callq 0x110dd
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/semind.c
// Function: command_rm
static void command_rm(int argc, char **argv)
{
	sqlite3_stmt *stmt;

	sqlite_command("BEGIN IMMEDIATE");
	sqlite_prepare("DELETE FROM file WHERE name GLOB @file", &stmt);

	if (semind_verbose > 1)
		message("SQL: %s", sqlite3_sql(stmt));

	for (int i = 0; i < argc; i++) {
		sqlite_bind_text(stmt, "@file",  argv[i], -1);
		sqlite_run(stmt);
		sqlite_reset_stmt(stmt);
	}

	sqlite3_finalize(stmt);
	sqlite_command("COMMIT");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x34997(%rip), %rdi     # 0x452cd
callq 0x113c7
leaq 0x34dad(%rip), %r14     # 0x456ef
movq %rsp, %r15
movq 0x5dd94(%rip), %rdi     # 0x6e6e0
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xf4a0
cmpl $0x5, %eax
je 0x10945
testl %eax, %eax
jne 0x10a50
cmpl $0x2, 0x5dd79(%rip)     # 0x6e6ec
jge 0x10a2d
testl %ebp, %ebp
jle 0x10a09
movl %ebp, %ebp
leaq 0x34d86(%rip), %r14     # 0x45710
xorl %r15d, %r15d
movq (%rsp), %r12
movq (%rbx,%r15,8), %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0xf480
movq %r12, %rdi
movl %eax, %esi
movq %r13, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %r8d, %r8d
callq 0xf2e0
testl %eax, %eax
jne 0x109e0
movq (%rsp), %rdi
callq 0x1139f
movq (%rsp), %r12
movq %r12, %rdi
callq 0xf110
movq %r12, %rdi
callq 0xf080
incq %r15
cmpq %r15, %rbp
jne 0x1098d
jmp 0x10a09
movq 0x5dcf9(%rip), %rdi     # 0x6e6e0
callq 0xf3d0
movl $0x1, %edi
xorl %esi, %esi
leaq 0x34a79(%rip), %rdx     # 0x45473
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xf570
jmp 0x109b9
movq (%rsp), %rdi
callq 0xf290
leaq 0x348c4(%rip), %rdi     # 0x452dd
callq 0x113c7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rdi
callq 0xf0e0
leaq 0x34cd9(%rip), %rdx     # 0x45716
xorl %edi, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0xf570
jmp 0x10979
movq 0x5dc89(%rip), %rdi     # 0x6e6e0
callq 0xf3d0
leaq 0x34b37(%rip), %rdx     # 0x4559a
leaq 0x34c85(%rip), %r8      # 0x456ef
movl $0x1, %edi
xorl %esi, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0xf570
jmp 0x1096c
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/semind.c
// Function: show_usage
static void show_usage(void)
{
	if (semind_command)
		printf("Try '%s %s --help' for more information.\n",
		       progname, semind_command);
	else
		printf("Try '%s --help' for more information.\n",
		       progname);
	exit(1);
}

// Assembly:
pushq %rax
movq 0x5d5f3(%rip), %rdx     # 0x6e6d8
movq 0x5c5d4(%rip), %rsi     # 0x6d6c0
testq %rdx, %rdx
jne 0x11101
leaq 0x341ae(%rip), %rdi     # 0x452a6
xorl %eax, %eax
callq 0xf050
jmp 0x1110f
leaq 0x34174(%rip), %rdi     # 0x4527c
xorl %eax, %eax
callq 0xf050
movl $0x1, %edi
callq 0xf120
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/semind.c
// Function: r_symbol
static void r_symbol(unsigned mode, struct position *pos, struct symbol *sym)
{
	static struct ident null;
	struct ident *ctx = &null;
	struct index_record rec;

	update_stream();

	if (semind_streams[pos->stream].id == -1)
		return;

	if (!semind_include_local_syms && sym_is_local(sym))
		return;

	if (!sym->ident) {
		warning(*pos, "empty ident");
		return;
	}

	if (dissect_ctx)
		ctx = dissect_ctx->ident;

	rec.context = ctx->name;
	rec.ctx_len = ctx->len;
	rec.symbol  = sym->ident->name;
	rec.sym_len = sym->ident->len;
	rec.kind    = sym->kind;
	rec.mode    = mode;
	rec.file    = semind_streams[pos->stream].id;
	rec.line    = pos->line;
	rec.col     = pos->pos;

	insert_record(&rec);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
callq 0x11418
movq 0x5d5d0(%rip), %rax     # 0x6e728
movq (%r15), %rdi
movl %edi, %ecx
shrl $0x3, %ecx
andl $0x1fff8, %ecx          # imm = 0x1FFF8
movq (%rax,%rcx), %rcx
cmpq $-0x1, %rcx
je 0x11227
cmpb $0x0, 0x5d56d(%rip)     # 0x6e6e8
je 0x1119b
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x111b9
leaq 0x5da43(%rip), %rax     # 0x6ebd0
movq (%rax), %rax
testq %rax, %rax
je 0x111d0
movq 0x18(%rax), %rsi
jmp 0x111d7
movq 0x30(%r14), %rax
leaq 0x5aaa2(%rip), %rdx     # 0x6bc48
cmpq %rax, (%rdx)
je 0x1117d
leaq 0x5aa9e(%rip), %rdx     # 0x6bc50
cmpq %rax, (%rdx)
jne 0x11227
jmp 0x1117d
leaq 0x3427d(%rip), %rsi     # 0x4543d
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x133dc
leaq 0x5d559(%rip), %rsi     # 0x6e730
leaq 0x12(%rsi), %r8
movq %rsp, %rax
movq %r8, (%rax)
movzbl 0x10(%rsi), %esi
movl %esi, 0x8(%rax)
leaq 0x12(%rdx), %rsi
movq %rsi, 0x10(%rax)
movzbl 0x10(%rdx), %edx
movl %edx, 0x18(%rax)
movsbl 0xd0(%r14), %edx
movl %edx, 0x1c(%rax)
movl %ebx, 0x20(%rax)
movq %rcx, 0x30(%rax)
movq %rdi, %rcx
shrq $0x20, %rcx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, 0x38(%rax)
shrl $0x16, %edi
movl %edi, 0x3c(%rax)
movq %rax, %rdi
callq 0x11797
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/semind.c
// Function: r_member
static void r_member(unsigned mode, struct position *pos, struct symbol *sym, struct symbol *mem)
{
	static struct ident null;
	static char memname[1024];
	struct ident *ni, *si, *mi;
	struct ident *ctx = &null;
	struct index_record rec;

	update_stream();

	if (semind_streams[pos->stream].id == -1)
		return;

	if (!semind_include_local_syms && sym_is_local(sym))
		return;

	ni = built_in_ident("?");
	si = sym->ident ?: ni;
	/* mem == NULL means entire struct accessed */
	mi = mem ? (mem->ident ?: ni) : built_in_ident("*");

	if (dissect_ctx)
		ctx = dissect_ctx->ident;

	snprintf(memname, sizeof(memname), "%.*s.%.*s", si->len, si->name, mi->len, mi->name);

	rec.context = ctx->name;
	rec.ctx_len = ctx->len;
	rec.symbol  = memname;
	rec.sym_len = si->len + mi->len + 1;
	rec.kind    = 'm';
	rec.mode    = mode;
	rec.file    = semind_streams[pos->stream].id;
	rec.line    = pos->line;
	rec.col     = pos->pos;

	insert_record(&rec);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movl %edi, %ebp
callq 0x11418
movq 0x5d4d2(%rip), %rax     # 0x6e728
movl (%rbx), %ecx
shrl $0x3, %ecx
andl $0x1fff8, %ecx          # imm = 0x1FFF8
cmpq $-0x1, (%rax,%rcx)
je 0x11390
cmpb $0x0, 0x5d475(%rip)     # 0x6e6e8
je 0x112a2
leaq 0x3ef70(%rip), %rdi     # 0x501ec
callq 0x23c18
movq 0x18(%r12), %r12
testq %r12, %r12
cmoveq %rax, %r12
testq %r15, %r15
je 0x112c5
movq %rax, %r14
movq 0x18(%r15), %rax
testq %rax, %rax
cmovneq %rax, %r14
jmp 0x112d4
movq 0x30(%r12), %rax
leaq 0x5a99a(%rip), %rcx     # 0x6bc48
cmpq %rax, (%rcx)
je 0x11275
leaq 0x5a996(%rip), %rcx     # 0x6bc50
cmpq %rax, (%rcx)
jne 0x11390
jmp 0x11275
leaq 0x3f214(%rip), %rdi     # 0x504e0
callq 0x23c18
movq %rax, %r14
leaq 0x5d8f5(%rip), %rax     # 0x6ebd0
movq (%rax), %rax
testq %rax, %rax
je 0x112e9
movq 0x18(%rax), %r13
jmp 0x112f0
leaq 0x5d460(%rip), %r13     # 0x6e750
movzbl 0x10(%r12), %ecx
leaq 0x12(%r12), %r8
movzbl 0x10(%r14), %r9d
leaq 0x12(%r14), %rax
movq %rax, (%rsp)
leaq 0x5d461(%rip), %r15     # 0x6e770
leaq 0x341a8(%rip), %rdx     # 0x454be
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
xorl %eax, %eax
callq 0xf090
leaq 0x12(%r13), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movzbl 0x10(%r13), %eax
movl %eax, 0x8(%rdi)
movq %r15, 0x10(%rdi)
movzbl 0x10(%r12), %eax
movzbl 0x10(%r14), %ecx
leal 0x1(%rax,%rcx), %eax
movl %eax, 0x18(%rdi)
movl $0x6d, 0x1c(%rdi)
movl %ebp, 0x20(%rdi)
movq 0x5d3c8(%rip), %rax     # 0x6e728
movq (%rbx), %rcx
movl %ecx, %edx
shrl $0x3, %edx
andl $0x1fff8, %edx          # imm = 0x1FFF8
movq (%rax,%rdx), %rax
movq %rax, 0x30(%rdi)
movq %rcx, %rax
shrq $0x20, %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, 0x38(%rdi)
shrl $0x16, %ecx
movl %ecx, 0x3c(%rdi)
callq 0x11797
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/semind.c
// Function: sqlite_run
static int sqlite_run(sqlite3_stmt *stmt)
{
	int ret = sqlite3_step(stmt);
	if (ret != SQLITE_DONE && ret != SQLITE_ROW)
		semind_error(1, 0, "unable to process query: %s: %s", sqlite3_errmsg(semind_db), sqlite3_sql(stmt));
	return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf300
movl %eax, %ebp
addl $-0x66, %eax
cmpl $-0x3, %eax
jbe 0x113bd
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0xf683
jmp 0x113b4
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/semind.c
// Function: sqlite_command
static void sqlite_command(const char *sql)
{
	sqlite3_stmt *stmt;
	sqlite_prepare(sql, &stmt);
	sqlite_run(stmt);
	sqlite3_finalize(stmt);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq 0x5d308(%rip), %rdi     # 0x6e6e0
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xf4a0
cmpl $0x5, %eax
je 0x113d1
testl %eax, %eax
jne 0x1140e
movq (%rsp), %rdi
callq 0x1139f
movq (%rsp), %rdi
callq 0xf290
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0xf6c1
jmp 0x113f4
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/semind.c
// Function: insert_record
static void insert_record(struct index_record *rec)
{
	sqlite_bind_text(insert_rec_stmt,  "@context", rec->context, rec->ctx_len);
	sqlite_bind_text(insert_rec_stmt,  "@symbol",  rec->symbol, rec->sym_len);
	sqlite_bind_int64(insert_rec_stmt, "@kind",    rec->kind);
	sqlite_bind_int64(insert_rec_stmt, "@mode",    rec->mode);
	sqlite_bind_int64(insert_rec_stmt, "@file",    rec->file);
	sqlite_bind_int64(insert_rec_stmt, "@line",    rec->line);
	sqlite_bind_int64(insert_rec_stmt, "@column",  rec->col);
	sqlite_run(insert_rec_stmt);
	sqlite_reset_stmt(insert_rec_stmt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x5cf60(%rip), %r14     # 0x6e708
movq (%rdi), %r15
movl 0x8(%rdi), %ebp
leaq 0x33cde(%rip), %rsi     # 0x45493
movq %r14, %rdi
callq 0xf480
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0xf2e0
testl %eax, %eax
jne 0x11922
movq 0x5cf2a(%rip), %r14     # 0x6e708
movq 0x10(%rbx), %r15
movl 0x18(%rbx), %ebp
leaq 0x33cb0(%rip), %rsi     # 0x4549c
movq %r14, %rdi
callq 0xf480
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0xf2e0
testl %eax, %eax
jne 0x1192c
movq 0x5cef3(%rip), %r14     # 0x6e708
movslq 0x1c(%rbx), %r15
leaq 0x33c84(%rip), %rsi     # 0x454a4
movq %r14, %rdi
callq 0xf480
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0xf250
testl %eax, %eax
jne 0x11936
movq 0x5cec4(%rip), %r14     # 0x6e708
movl 0x20(%rbx), %r15d
leaq 0x33c5b(%rip), %rsi     # 0x454aa
movq %r14, %rdi
callq 0xf480
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0xf250
testl %eax, %eax
jne 0x11940
movq 0x5ce95(%rip), %r14     # 0x6e708
movq 0x30(%rbx), %r15
leaq 0x33e92(%rip), %rsi     # 0x45710
movq %r14, %rdi
callq 0xf480
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0xf250
testl %eax, %eax
jne 0x1194a
movq 0x5ce66(%rip), %r14     # 0x6e708
movslq 0x38(%rbx), %r15
leaq 0x33c03(%rip), %rsi     # 0x454b0
movq %r14, %rdi
callq 0xf480
movq %r14, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0xf250
testl %eax, %eax
jne 0x11954
movq 0x5ce37(%rip), %r14     # 0x6e708
movslq 0x3c(%rbx), %rbx
leaq 0x33bda(%rip), %rsi     # 0x454b6
movq %r14, %rdi
callq 0xf480
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0xf250
testl %eax, %eax
jne 0x1195e
movq 0x5ce0c(%rip), %rdi     # 0x6e708
callq 0x1139f
movq 0x5ce00(%rip), %rbx     # 0x6e708
movq %rbx, %rdi
callq 0xf110
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf080
callq 0xf824
jmp 0x117d7
callq 0xf850
jmp 0x1180e
callq 0xf87c
jmp 0x1183d
callq 0xf8a8
jmp 0x1186c
callq 0xf8d4
jmp 0x1189b
callq 0xf900
jmp 0x118ca
callq 0xf92c
jmp 0x118f5
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/dissect.c
// Function: do_symbol
static inline struct symbol *do_symbol(struct symbol *sym)
{
	struct symbol *type = base_type(sym);
	struct symbol *dctx = dissect_ctx;
	struct statement *stmt;

	reporter->r_symdef(sym);

	switch (type->type) {
	default:
		if (!sym->initializer)
			break;
		reporter->r_symbol(U_W_VAL, &sym->pos, sym);
		if (!dctx)
			dissect_ctx = sym;
		do_initializer(type, sym->initializer);
		dissect_ctx = dctx;

	break; case SYM_FN:
		stmt = sym->ctype.modifiers & MOD_INLINE
			? type->inline_stmt : type->stmt;
		if (!stmt)
			break;

		if (dctx)
			sparse_error(dctx->pos, "dissect_ctx change %s -> %s",
				show_ident(dctx->ident), show_ident(sym->ident));

		dissect_ctx = sym;
		do_sym_list(type->arguments);
		do_statement(U_VOID, stmt);
		dissect_ctx = dctx;
	}

	return type;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x12d88
movq %rax, %r14
movq 0x5c942(%rip), %r13     # 0x6ebd0
movq 0x5c933(%rip), %rax     # 0x6ebc8
movq %rbx, %rdi
callq *(%rax)
cmpb $0x5, (%r14)
jne 0x12310
movb 0x68(%rbx), %al
andb $0x40, %al
shrb $0x6, %al
movzbl %al, %eax
shll $0x4, %eax
movq 0x90(%rax,%r14), %r15
testq %r15, %r15
je 0x12352
testq %r13, %r13
je 0x122f1
movq 0x18(%r13), %rdi
callq 0x232a9
movq %rax, %r12
movq 0x18(%rbx), %rdi
callq 0x232a9
movq 0x4(%r13), %rdi
leaq 0x342b8(%rip), %rsi     # 0x4659c
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x13560
movq %rbx, 0x5c8d8(%rip)     # 0x6ebd0
movq 0x88(%r14), %rdi
callq 0x12062
xorl %edi, %edi
movq %r15, %rsi
callq 0x12b06
jmp 0x1234b
cmpq $0x0, 0xb0(%rbx)
je 0x12352
movq 0x5c8a7(%rip), %rax     # 0x6ebc8
leaq 0x4(%rbx), %rsi
movl $0x8, %edi
movq %rbx, %rdx
callq *0x10(%rax)
testq %r13, %r13
jne 0x1233c
movq %rbx, 0x5c894(%rip)     # 0x6ebd0
movq 0xb0(%rbx), %rsi
movq %r14, %rdi
callq 0x12dba
movq %r13, 0x5c87e(%rip)     # 0x6ebd0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/dissect.c
// Function: deanon
static bool deanon(struct symbol *base, struct ident *node, struct symbol *parent)
{
	struct ident *pi = parent ? parent->ident : NULL;
	char name[256];

	if (!node) {
		base->ident = pi;
		return false;
	}

	snprintf(name, sizeof(name), "%.*s:%.*s",
		pi ? pi->len : 0, pi ? pi->name : NULL, node->len, node->name);

	base->ident = built_in_ident(name);
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x12a9e
movq 0x18(%rdx), %rax
jmp 0x12aa0
xorl %eax, %eax
testq %r14, %r14
je 0x12aed
testq %rax, %rax
je 0x12ab0
movzbl 0x10(%rax), %ecx
jmp 0x12ab2
xorl %ecx, %ecx
leaq 0x12(%rax), %r8
testq %rax, %rax
cmoveq %rax, %r8
movzbl 0x10(%r14), %r9d
leaq 0x12(%r14), %rax
movq %rax, (%rsp)
leaq 0x33ac1(%rip), %rdx     # 0x46592
leaq 0x10(%rsp), %r15
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
xorl %eax, %eax
callq 0xf090
movq %r15, %rdi
callq 0x23c18
testq %r14, %r14
setne %cl
movq %rax, 0x18(%rbx)
movl %ecx, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/dissect.c
// Function: base_type
static struct symbol *base_type(struct symbol *sym)
{
	if (!sym)
		return &bad_ctype;

	if (sym->type == SYM_NODE)
		examine_sym_node(sym, NULL);

	return sym->ctype.base_type	// builtin_fn_type
		?: &bad_ctype;
}

// Assembly:
testq %rdi, %rdi
je 0x12db2
pushq %rbx
movq %rdi, %rbx
cmpb $0x3, (%rdi)
jne 0x12da0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x120b4
movq 0x60(%rbx), %rax
testq %rax, %rax
jne 0x12db0
leaq 0x61e50(%rip), %rax     # 0x74c00
popq %rbx
retq
leaq 0x61e47(%rip), %rax     # 0x74c00
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/dissect.c
// Function: report_implicit
static void report_implicit(usage_t mode, struct position *pos, struct symbol *type)
{
	if (type->type != SYM_STRUCT && type->type != SYM_UNION)
		return;

	if (type->ident != NULL)
		reporter->r_member(mode, pos, type, NULL);

	DO_LIST(type->symbol_list, mem,
		report_implicit(mode, pos, base_type(mem)));
}

// Assembly:
movzbl (%rdx), %eax
addl $-0x7, %eax
cmpl $0x1, %eax
ja 0x1306f
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
cmpq $0x0, 0x18(%rdx)
je 0x1300f
movq 0x5bbc6(%rip), %rax     # 0x6ebc8
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq *0x18(%rax)
movq 0x98(%r14), %r14
testq %r14, %r14
je 0x13067
movq %r14, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0x1305e
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x1303d
testq %rdi, %rdi
je 0x1304f
callq 0x12d88
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x12fd5
incq %r12
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jl 0x13029
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0x1301e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/dissect.c
// Function: report_member
static struct symbol *report_member(usage_t mode, struct position *pos,
					struct symbol *type, struct symbol *mem)
{
	struct symbol *ret = mem->ctype.base_type;

	if (mem->ident || mem->type == SYM_BAD)
		reporter->r_member(fix_mode(ret, mode), pos, type, mem);

	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %esi
movq 0x60(%rcx), %rbx
cmpq $0x0, 0x18(%rcx)
jne 0x13095
cmpb $0x10, (%r14)
jne 0x130b6
movq 0x5bb2c(%rip), %rax     # 0x6ebc8
movq 0x18(%rax), %r13
movq %rbx, %rdi
callq 0x13127
movl %eax, %edi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *%r13
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/dissect.c
// Function: fix_mode
static usage_t fix_mode(struct symbol *type, usage_t mode)
{
	mode &= (U_SELF | (U_SELF << U_SHIFT));

	switch (type->type) {
		case SYM_BASETYPE:
			if (!type->ctype.base_type)
				break;
		case SYM_ENUM:
		case SYM_BITFIELD:
			if (mode & U_MASK)
				mode &= U_SELF;
		default:

		break; case SYM_FN:
			if (mode & U_R_VAL)
				mode |= U_R_AOF;
			mode &= ~(U_R_VAL | U_W_AOF);

		break; case SYM_ARRAY:
			if (mode & (U_MASK << U_SHIFT))
				mode >>= U_SHIFT;
			else if (mode != U_W_VAL)
				mode = u_addr(mode);
	}

	if (!(mode & U_R_AOF))
		mode &= ~U_W_AOF;

	return mode;
}

// Assembly:
movzwl %si, %ecx
movzbl (%rdi), %eax
addl $-0x2, %eax
cmpl $0x9, %eax
ja 0x1317f
leaq 0x33408(%rip), %rdx     # 0x46544
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
testb $0xd, %sil
jne 0x13167
jmp 0x1317f
testl $0xd00, %esi            # imm = 0xD00
je 0x1318b
shrl $0x8, %ecx
jmp 0x1317f
testb $0xd, %sil
je 0x1317f
cmpq $0x0, 0x60(%rdi)
je 0x1317f
movzbl %sil, %ecx
jmp 0x1317f
movl %esi, %eax
shrl $0x2, %eax
andl $0x1, %eax
andl $0xfff9, %esi           # imm = 0xFFF9
orl %eax, %esi
movl %esi, %ecx
movl %ecx, %eax
andl $-0x4, %eax
testb $0x1, %cl
cmovnel %ecx, %eax
retq
cmpl $0x8, %ecx
movl $0x8, %ecx
je 0x1317f
movl %esi, %eax
andl $0xd, %eax
andl $0x2, %esi
incl %esi
testl %eax, %eax
cmovel %eax, %esi
jmp 0x1317d