LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/tkln[P]mcwm/mcwm.c
// Function: getrandr
void getrandr(void)
{
    xcb_randr_get_screen_resources_current_cookie_t rcookie;
    xcb_randr_get_screen_resources_current_reply_t *res;
    xcb_randr_output_t *outputs;
    int len;    
    xcb_timestamp_t timestamp;
    
    rcookie = xcb_randr_get_screen_resources_current(conn, screen->root);
    res = xcb_randr_get_screen_resources_current_reply(conn, rcookie, NULL);
    if (NULL == res)
    {
        printf("No RANDR extension available.\n");
        return;
    }
    timestamp = res->config_timestamp;

    len = xcb_randr_get_screen_resources_current_outputs_length(res);
    outputs = xcb_randr_get_screen_resources_current_outputs(res);

    PDEBUG("Found %d outputs.\n", len);
    
    /* Request information for all outputs. */
    getoutputs(outputs, len, timestamp);

    free(res);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x44b4(%rip), %rdi      # 0xa978
movq 0x447d(%rip), %rax      # 0xa948
movl (%rax), %esi
callq 0x3220
movq 0x449f(%rip), %rdi      # 0xa978
movl %eax, %esi
xorl %edx, %edx
callq 0x3370
testq %rax, %rax
je 0x6519
movq %rax, %rbx
movl 0xc(%rax), %ebp
movq %rax, %rdi
callq 0x3550
movl %eax, %r14d
movq %rbx, %rdi
callq 0x3230
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x6529
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3040
leaq 0x105d(%rip), %rdi      # 0x757d
popq %rbx
popq %r14
popq %rbp
jmp 0x30c0
// File: /workspace/github_c_makefile_star2_O2/tkln[P]mcwm/mcwm.c
// Function: finishtabbing
void finishtabbing(void)
{
    mode = 0;
    
    if (NULL != lastfocuswin)
    {
        movetohead(&wslist[curws], lastfocuswin->wsitem[curws]);
        lastfocuswin = NULL;             
    }
                
    movetohead(&wslist[curws], focuswin->wsitem[curws]);
}

// Assembly:
pushq %rax
andl $0x0, 0x3e45(%rip)      # 0xa8d8
movq 0x3f06(%rip), %rax      # 0xa9a0
testq %rax, %rax
je 0x6ac2
movl 0x3e1b(%rip), %ecx      # 0xa8c0
leaq 0x3e34(%rip), %rdx      # 0xa8e0
leaq (%rdx,%rcx,8), %rdi
movq 0x48(%rax,%rcx,8), %rsi
callq 0x6ae8
andq $0x0, 0x3ede(%rip)      # 0xa9a0
movl 0x3df8(%rip), %eax      # 0xa8c0
leaq 0x3e11(%rip), %rcx      # 0xa8e0
leaq (%rcx,%rax,8), %rdi
movq 0x3e66(%rip), %rcx      # 0xa940
movq 0x48(%rcx,%rax,8), %rsi
popq %rax
jmp 0x6ae8
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/tkln[P]mcwm/list.c
// Function: freeitem
void freeitem(struct item **list, int *stored,
              struct item *item)
{
    if (NULL == list || NULL == *list || NULL == item)
    {
        return;
    }
    
    if (NULL != item->data)
    {
        free(item->data);
        item->data = NULL;
    }

    delitem(list, item);

    if (NULL != stored)
    {
        (*stored) --;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x6be9
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
testq %rdx, %rdx
je 0x6be4
movq %rdi, %r15
cmpq $0x0, (%rdi)
je 0x6be4
movq %rsi, %rbx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x6bd2
callq 0x3040
andq $0x0, (%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x6b64
testq %rbx, %rbx
je 0x6be4
decl (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/tkln[P]mcwm/list.c
// Function: delallitems
void delallitems(struct item **list, int *stored)
{
    struct item *item;
    struct item *next;
    
    for (item = *list; item != NULL; item = next)
    {
        next = item->next;
        free(item->data);
        delitem(list, item);
    }

    if (NULL != stored)
    {
        (*stored) = 0;
    }    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
testq %r15, %r15
je 0x6c1c
movq (%r15), %rdi
movq 0x10(%r15), %r12
callq 0x3040
movq %r14, %rdi
movq %r15, %rsi
callq 0x6b64
movq %r12, %r15
jmp 0x6bfb
testq %rbx, %rbx
je 0x6c24
andl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/src/list.c
// Function: SH_List__init
SH_List*
SH_List__init(int* err) {
	SH_List* obj;

	__cascade(err, (SH_List*)0);

	obj = (SH_List*)malloc(sizeof(SH_List));
	if ((SH_List*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_List*)0;
	}

	obj->count = 0;

	__clear(err);
	return obj;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x117e
cmpl $0x0, (%rbx)
je 0x117e
xorl %eax, %eax
jmp 0x11a7
movl $0x2008, %edi           # imm = 0x2008
callq 0x1070
testq %rax, %rax
je 0x1199
andq $0x0, 0x2000(%rax)
xorl %ecx, %ecx
jmp 0x11a0
movl $0x80000001, %ecx       # imm = 0x80000001
xorl %eax, %eax
testq %rbx, %rbx
je 0x11a7
movl %ecx, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/src/list.c
// Function: SH_List__destroy
void
SH_List__destroy(SH_List* obj, sh_bool_t recursive, int* err) {
	int local_err;
	int final_err = SH_E_NO_ERROR;
	size_t i;
	__cascade(err,);
	if (recursive) {
		for (i = 0; i < obj->count; i++) {
			local_err = SH_E_NO_ERROR;
			SH_Item__destroy(obj->_list[i], recursive, &local_err);
			if (final_err == SH_E_NO_ERROR && local_err != SH_E_NO_ERROR) {
				final_err = local_err;
			}
		}
		free(obj);
		__raise(err, final_err);
	} else {
		free(obj);
		__clear(err);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x11c4
cmpl $0x0, (%rbx)
jne 0x1227
testb %sil, %sil
je 0x1214
xorl %r12d, %r12d
movzbl %sil, %ebp
leaq 0x4(%rsp), %r15
xorl %r13d, %r13d
cmpq 0x2000(%r14), %r13
jae 0x120a
andl $0x0, 0x4(%rsp)
movq (%r14,%r13,8), %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x1040
movl 0x4(%rsp), %eax
testl %eax, %eax
cmovel %r12d, %eax
testl %r12d, %r12d
cmovel %eax, %r12d
incq %r13
jmp 0x11d8
movq %r14, %rdi
callq 0x1030
jmp 0x121f
movq %r14, %rdi
callq 0x1030
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x1227
movl %r12d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/src/list.c
// Function: SH_List__add
void
SH_List__add(SH_List* obj, SH_Item* item, int* err) {
	__cascade(err,);
	if (obj->count >= SH_LIST_CAPACITY) {
		__raise(err, SH_E_LIST_OVERFLOW);
		return;
	}
	obj->_list[obj->count++] = item;
	__clear(err);
}

// Assembly:
testq %rdx, %rdx
je 0x1241
cmpl $0x0, (%rdx)
je 0x1260
retq
movq 0x2000(%rdi), %rax
cmpq $0x3ff, %rax            # imm = 0x3FF
ja 0x1240
leaq 0x1(%rax), %rcx
movq %rcx, 0x2000(%rdi)
movq %rsi, (%rdi,%rax,8)
retq
movq 0x2000(%rdi), %rax
cmpq $0x400, %rax            # imm = 0x400
jb 0x1276
movl $0x300001, (%rdx)       # imm = 0x300001
retq
leaq 0x1(%rax), %rcx
movq %rcx, 0x2000(%rdi)
movq %rsi, (%rdi,%rax,8)
andl $0x0, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/src/list.c
// Function: _SH_List__to_s_item
void
__SH_List__to_s_item(SH_Item* obj, void* ptr, int* err) {
	__sh_list__string* str;

	sh_char_t* s;

	int local_err = SH_E_NO_ERROR;

	__cascade(err,);

	str = (__sh_list__string*)ptr;

	s = SH_Item__to_s(obj, &local_err);
	if (local_err) {
		__raise(err, local_err);
		return;
	}

	str->a[str->n ++] = s; str->length += strlen((const char*)s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
andl $0x0, 0xc(%rsp)
testq %rdx, %rdx
je 0x134f
cmpl $0x0, (%r14)
jne 0x1389
leaq 0xc(%rsp), %r15
movq %r15, %rsi
callq 0x1090
movl (%r15), %ecx
testl %ecx, %ecx
je 0x136d
testq %r14, %r14
je 0x1389
movl %ecx, (%r14)
jmp 0x1389
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq %rax, 0x10(%rbx,%rcx,8)
movq %rax, %rdi
callq 0x1050
addq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/src/list.c
// Function: SH_List__to_s
sh_char_t*
SH_List__to_s(SH_List* obj, int* err) {
	sh_char_t* tmp_s;
	sh_char_t* s;
	sh_char_t* ptr;

	size_t i;
	size_t n;
	size_t total;

	__sh_list__string str;
	str.length = (size_t)0;
	str.n = (size_t)0;

	SH_List__each(obj, &__SH_List__to_s_item, (void*)(&str), err);
	if (__catch(err)) {
		for (i = 0; i < str.n; i++) {
			free(str.a[i]);
		}
		__cascade(err, (sh_char_t*)0);
	}

	total = 0;
	total += str.length;
	if (str.n > 1)
		total += (str.n - 1) * 2; /* ', ' between items */
	total += 1; /* NULL */

	s = (sh_char_t*)malloc(sizeof(sh_char_t) * total);
	if ((sh_char_t*)0 == s) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (sh_char_t*)0;
	}

	ptr = s;

	for (i = 0; i < str.n; i++) {
		if (i > 0) {
			*ptr = ',';
			ptr ++;

			*ptr = ' ';
			ptr ++;
		}

		tmp_s = str.a[i];
		n = strlen((const char*)tmp_s);
		memcpy((void*)ptr, (const void*)tmp_s, n);
		free(str.a[i]);
		ptr += n;
	}

	*ptr = SH_CHAR_C(0);

	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rsi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x2c22(%rip), %rsi      # 0x3fd8
movq %r14, %rcx
callq 0x1080
testq %r14, %r14
je 0x13eb
cmpl $0x0, (%r14)
je 0x13eb
xorl %ebx, %ebx
cmpq 0x8(%rsp), %rbx
jae 0x13e1
movq 0x10(%rsp,%rbx,8), %rdi
callq 0x1030
incq %rbx
jmp 0x13cb
cmpl $0x0, (%r14)
jne 0x1478
movq (%rsp), %rax
movq 0x8(%rsp), %r15
xorl %ecx, %ecx
cmpq $0x2, %r15
leaq -0x2(%r15,%r15), %rdx
cmovaeq %rdx, %rcx
leaq (%rax,%rcx), %rdi
incq %rdi
callq 0x1070
testq %rax, %rax
je 0x146c
movq %rax, %rbx
xorl %r13d, %r13d
movq %rax, %r14
cmpq %r15, %r13
jae 0x1466
testq %r13, %r13
je 0x1431
movw $0x202c, (%r14)         # imm = 0x202C
addq $0x2, %r14
movq 0x10(%rsp,%r13,8), %r15
movq %r15, %rdi
callq 0x1050
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1060
movq 0x10(%rsp,%r13,8), %rdi
callq 0x1030
addq %r12, %r14
incq %r13
movq 0x8(%rsp), %r15
jmp 0x141d
movb $0x0, (%r14)
jmp 0x147a
testq %r14, %r14
je 0x1478
movl $0x80000001, (%r14)     # imm = 0x80000001
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x2010, %rsp           # imm = 0x2010
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_5/5.5/mmap-write.c
// Function: main
int main (int argc, char* const argv[])
{
  int fd;
  void* file_memory;

  /* Seed the random number generator.*/
  srand (time (NULL));

  /* Prepare a file large enough to hold an unsigned integer. */
  fd = open (argv[1], O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
  lseek (fd, FILE_LENGTH+1, SEEK_SET);
  write (fd, "", 1);
  lseek (fd, 0, SEEK_SET);

  /* Create the memory mapping. */
  file_memory = mmap (0, FILE_LENGTH, PROT_WRITE, MAP_SHARED, fd, 0);
  close (fd);
  /* Write a random integer to memory-mapped area. */
  sprintf((char*) file_memory, "%d\n", random_range (-100, 100));

  /* Release the memory (unnecessary because the program exits). */
  munmap (file_memory, FILE_LENGTH);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
xorl %edi, %edi
callq 0x1080
movl %eax, %edi
callq 0x1070
movq 0x8(%rbx), %rdi
pushq $0x42
popq %rsi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x10a0
movl %eax, %ebx
movl $0x101, %esi            # imm = 0x101
movl %eax, %edi
xorl %edx, %edx
callq 0x1050
leaq 0xdcc(%rip), %rsi       # 0x2013
pushq $0x1
popq %rdx
movl %ebx, %edi
callq 0x1030
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1050
pushq $0x2
popq %rdx
pushq $0x1
popq %rcx
movl $0x100, %esi            # imm = 0x100
xorl %edi, %edi
movl %ebx, %r8d
xorl %r9d, %r9d
callq 0x1040
movq %rax, %r14
movl %ebx, %edi
callq 0x1060
pushq $-0x64
popq %rdi
pushq $0x64
popq %rsi
callq 0x11cc
leaq 0xd80(%rip), %rsi       # 0x2010
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x10b0
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0x1090
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mijallen[P]SimpleHTTPServer/lib/libyaml/tests/run-scanner.c
// Function: main
int
main(int argc, char *argv[])
{
    int number;

    if (argc < 2) {
        printf("Usage: %s file1.yaml ...\n", argv[0]);
        return 0;
    }

    for (number = 1; number < argc; number ++)
    {
        FILE *file;
        yaml_parser_t parser;
        yaml_token_t token;
        int done = 0;
        int count = 0;
        int error = 0;

        printf("[%d] Scanning '%s': ", number, argv[number]);
        fflush(stdout);

        file = fopen(argv[number], "rb");
        assert(file);

        assert(yaml_parser_initialize(&parser));

        yaml_parser_set_input_file(&parser, file);

        while (!done)
        {
            if (!yaml_parser_scan(&parser, &token)) {
                error = 1;
                break;
            }

            done = (token.type == YAML_STREAM_END_TOKEN);

            yaml_token_delete(&token);

            count ++;
        }

        yaml_parser_delete(&parser);

        assert(!fclose(file));

        printf("%s (%d tokens)\n", (error ? "FAILURE" : "SUCCESS"), count);
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %rbx
cmpl $0x2, %edi
jge 0x120a
movq (%rbx), %rsi
leaq 0xe15(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1060
xorl %eax, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edi, %eax
movq %rax, 0x10(%rsp)
pushq $0x1
popq %r14
leaq 0x68(%rsp), %r13
leaq 0x18(%rsp), %rbp
movq %rbx, 0x8(%rsp)
cmpq 0x10(%rsp), %r14
je 0x11f6
movq (%rbx,%r14,8), %rdx
leaq 0xde8(%rip), %rdi       # 0x201e
movl %r14d, %esi
xorl %eax, %eax
callq 0x1060
movq 0x2d99(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10a0
movq (%rbx,%r14,8), %rdi
leaq 0xdd9(%rip), %rsi       # 0x2033
callq 0x10b0
testq %rax, %rax
je 0x12fb
movq %rax, %r12
movq %r13, %rdi
callq 0x1090
testl %eax, %eax
je 0x1314
movq %r13, %rdi
movq %r12, %rsi
callq 0x1030
xorl %ebx, %ebx
xorl %r15d, %r15d
testl %ebx, %ebx
jne 0x12b5
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1040
testl %eax, %eax
je 0x12b5
xorl %ebx, %ebx
cmpl $0x2, 0x18(%rsp)
sete %bl
movq %rbp, %rdi
callq 0x10c0
incl %r15d
jmp 0x128b
movq %r13, %rdi
callq 0x1080
movq %r12, %rdi
callq 0x1050
testl %eax, %eax
jne 0x132d
testl %ebx, %ebx
leaq 0xdd4(%rip), %rsi       # 0x20a6
leaq 0xdc5(%rip), %rax       # 0x209e
cmoveq %rax, %rsi
leaq 0xdaa(%rip), %rdi       # 0x208e
movl %r15d, %edx
xorl %eax, %eax
callq 0x1060
incq %r14
movq 0x8(%rsp), %rbx
jmp 0x1224
leaq 0xd34(%rip), %rdi       # 0x2036
leaq 0xd32(%rip), %rsi       # 0x203b
leaq 0xd39(%rip), %rcx       # 0x2049
pushq $0x22
jmp 0x1344
leaq 0xd45(%rip), %rdi       # 0x2060
leaq 0xd19(%rip), %rsi       # 0x203b
leaq 0xd20(%rip), %rcx       # 0x2049
pushq $0x24
jmp 0x1344
leaq 0xd4c(%rip), %rdi       # 0x2080
leaq 0xd00(%rip), %rsi       # 0x203b
leaq 0xd07(%rip), %rcx       # 0x2049
pushq $0x38
popq %rdx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/vanhauser-thc[P]vulntest/tricky.c
// Function: main
int main(int argc, char *argv[]) {
  char buf[128];
  int user_len = atoi(argv[2]);
  int buf_size = sizeof(buf);

  if (user_len > buf_size) {
    printf("Attempted Overflow Detected\n");
    return -1;
  }

  memcpy(buf, argv[1], user_len);
  if (buf[0] != 0)
    return 0;
  else
    return -1;
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq 0x10(%rsi), %rdi
callq 0x1050
cmpl $0x81, %eax
jl 0x1188
leaq 0xe86(%rip), %rdi       # 0x2004
callq 0x1030
pushq $-0x1
popq %rax
jmp 0x11a1
movq 0x8(%rbx), %rsi
movslq %eax, %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1040
xorl %eax, %eax
cmpb $0x1, (%rbx)
sbbl %eax, %eax
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro8x/macro8x.c
// Function: printLine
void printLine( char *line, WORD32 loc, WORD32 val, LINESTYLE_T linestyle )
{
  if( listfile == NULL )
  {
    save_error_count = 0;
    return;
  }

  printPageBreak();

  list_lineno++;
  page_lineno++;
  switch( linestyle )
  {
  default:
  case LINE:
    fprintf( listfile, "%5d             ", lineno );
    fputs( line, listfile );
    listed = TRUE;
    break;

  case LINE_VAL:
    if( !listed )
    {
      fprintf( listfile, "%5d       %4.4o  ", lineno, val );
      fputs( line, listfile );
      listed = TRUE;
    }
    else
    {
      fprintf( listfile, "            %4.4o\n", val );
    }
    break;

  case LINE_LOC_VAL:
    if( !listed )
    {
      if( indirect_generated && lgm_flag )
      {
        fprintf( listfile, "%5d %5.5o %4.4o@ ", lineno, loc, val );
      }
      else
      {
        fprintf( listfile, "%5d %5.5o %4.4o  ", lineno, loc, val );
      }
      fputs( line, listfile );
      listed = TRUE;
    }
    else
    {
      fprintf( listfile, "      %5.5o %4.4o\n", loc, val );
    }
    break;

  case LOC_VAL:
    fprintf( listfile, "      %5.5o %4.4o\n", loc, val );
    break;
  }
  printErrorMessages();
}

// Assembly:
cmpq $0x0, 0x9823(%rip)      # 0xd370
je 0x3ba3
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x5c02
incl 0xa56d(%rip)            # 0xe0d8
incl 0xa56f(%rip)            # 0xe0e0
cmpl $0x1, %r15d
je 0x3bd2
cmpl $0x2, %r15d
je 0x3bab
cmpl $0x3, %r15d
je 0x3bb4
movq 0x97e6(%rip), %rdi      # 0xd370
movl 0xa540(%rip), %edx      # 0xe0d0
leaq 0x3c64(%rip), %rsi      # 0x77fb
xorl %eax, %eax
callq 0x2120
jmp 0x3c49
andl $0x0, 0x9682(%rip)      # 0xd22c
retq
cmpl $0x0, 0xa516(%rip)      # 0xe0c8
je 0x3bf4
movq 0x97b5(%rip), %rdi      # 0xd370
leaq 0x3c93(%rip), %rsi      # 0x7855
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2120
jmp 0x3c62
cmpl $0x0, 0xa4ef(%rip)      # 0xe0c8
movq 0x9790(%rip), %rdi      # 0xd370
je 0x3c33
leaq 0x3c35(%rip), %rsi      # 0x781e
movl %ebx, %edx
xorl %eax, %eax
callq 0x2120
jmp 0x3c62
cmpb $0x0, 0xa4d1(%rip)      # 0xe0cc
leaq 0x3c2f(%rip), %rsi      # 0x7831
leaq 0x3c3a(%rip), %rax      # 0x7843
cmoveq %rax, %rsi
cmpb $0x0, 0xa800(%rip)      # 0xe414
movq 0x9755(%rip), %rdi      # 0xd370
movl 0xa4af(%rip), %edx      # 0xe0d0
cmoveq %rax, %rsi
movl %ebp, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x2120
jmp 0x3c49
movl 0xa497(%rip), %edx      # 0xe0d0
leaq 0x3bcc(%rip), %rsi      # 0x780c
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2120
movq 0x9720(%rip), %rsi      # 0xd370
movq %r14, %rdi
callq 0x20c0
movl $0x1, 0xa466(%rip)      # 0xe0c8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5c6f
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro8x/macro8x.c
// Function: lexemeToName
char *lexemeToName( char *name, WORD32 from, WORD32 term )
{
  WORD32  to;

  to = 0;

  while( from < term && to < ( SYMLEN - 1 ))
  {
    name[to++] = toupper( line[from++] );
  }

  while( to < SYMLEN )
  {
    name[to++] = '\0';
  }
  return( name );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r15
movslq %edx, %r12
xorl %r14d, %r14d
leaq 0xa355(%rip), %r13      # 0xe0f0
leaq (%r15,%r14), %rbp
cmpq %r12, %rbp
jge 0x3dcc
cmpq $0x6, %r14
jae 0x3dcc
callq 0x2030
movq (%rax), %rax
movsbq (%r13,%rbp), %rcx
movb (%rax,%rcx,4), %al
movb %al, (%rbx,%r14)
incq %r14
jmp 0x3d9b
movb $0x0, (%rbx,%r14)
incq %r14
cmpq $0x6, %r14
jbe 0x3dc4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro8x/macro8x.c
// Function: errorMessage
void errorMessage( EMSG_T *mesg, WORD32 col )
{
  char   linecol[12];

  if( pass == 2 )
  {
    errors++;
    sprintf( linecol, "(%d:%d)", lineno, col + 1 );
    fprintf( errorfile, "%s%-9s : error:  %s at Loc = %5.5o\n",
                                         filename, linecol, mesg->file, clc );
    saveError( mesg->list, col );
  }
  error_in_line = TRUE;
}

// Assembly:
cmpl $0x2, 0x803e(%rip)      # 0xd230
jne 0x5264
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
incl 0x8020(%rip)            # 0xd228
movl 0x8ec2(%rip), %edx      # 0xe0d0
leal 0x1(%rbx), %ecx
leaq 0x2726(%rip), %rsi      # 0x793e
leaq 0x4(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2160
movq 0x7ff2(%rip), %rdi      # 0xd220
movq 0x8(%r14), %r8
movl 0x8267(%rip), %r9d      # 0xd4a0
leaq 0x272f(%rip), %rsi      # 0x796f
leaq 0x81d9(%rip), %rdx      # 0xd420
movq %r15, %rcx
xorl %eax, %eax
callq 0x2120
movq (%r14), %rdi
movl %ebx, %esi
callq 0x6110
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movb $0x1, 0x9009(%rip)      # 0xe274
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/crossassemblers/macro8x/macro8x.c
// Function: punchObject
void punchObject( WORD32 val )
{
  val &= 0377;
  if( objectfile != NULL )
  {
    fputc( val, objectfile );
    checksum += val;
  }
  binary_data_output = TRUE;
}

// Assembly:
movq 0x754e(%rip), %rsi      # 0xd2e0
testq %rsi, %rsi
je 0x5daa
pushq %rbx
movzbl %dil, %ebx
movl %ebx, %edi
callq 0x20e0
addl %ebx, 0x74a7(%rip)      # 0xd250
popq %rbx
movb $0x1, 0x53df(%rip)      # 0xb190
retq
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/tests/readseek3.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	int fd = open(tmpfile, O_RDONLY);
	unsigned long offset = getpagesize() * nr;

	assert(fd >= 0);

	while (1) {
		lseek(fd, offset, SEEK_SET);
		assert(read(fd, buf, BUFLEN) == BUFLEN);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x257c(%rip), %rdi      # 0x51a0
xorl %esi, %esi
xorl %eax, %eax
callq 0x2230
movl %eax, %ebp
callq 0x22a0
testl %ebp, %ebp
js 0x2c83
movslq %eax, %r14
imulq %r15, %r14
movq %rsp, %r15
movl %ebp, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2120
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r15, %rsi
callq 0x2170
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2c6a
incq (%rbx)
jmp 0x2c42
leaq 0x698(%rip), %rdi       # 0x3309
leaq 0x621(%rip), %rsi       # 0x3299
leaq 0x657(%rip), %rcx       # 0x32d6
pushq $0x28
jmp 0x2c9a
leaq 0x607(%rip), %rdi       # 0x3291
leaq 0x608(%rip), %rsi       # 0x3299
leaq 0x63e(%rip), %rcx       # 0x32d6
pushq $0x24
popq %rdx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/map_test.c
// Function: test_kvmap
static int
test_kvmap(const int argc, char ** const argv)
{
  struct oalloc * const oa = oalloc_create();
  debug_assert(oa);
  struct kvmap_mm mm = { .af = (kv_alloc_func)oalloc_alloc, .ap = oa, };
  //struct kvmap_mm mm = { .af = kv_alloc_malloc, .rf = kv_retire_free, };
  struct kvmap_api * api = NULL;
  const int n1 = kvmap_api_helper(argc, argv, &api, &mm, false);
  if (n1 < 0) {
    kvmap_help_message();
    oalloc_destroy(oa);
    return n1;
  }

  char *pref[64] = {};
  for (int i = 0; i < n1; i++) {
    pref[i] = argv[i];
  }
  pref[n1] = NULL;

  struct pass_info pi = {};
  pi.api = api;
  pi.vctr_size = 8;
  pi.wf = kvmap_worker;
  pi.af = kvmap_analyze;
  const int n2 = maptest_passes(argc - n1, argv + n1, pref, &pi);

  kvmap_api_destroy(api);
  oalloc_destroy(oa);
  if (n2 < 0) {
    kvmap_help_message();
    return n2;
  } else {
    return n1 + n2;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %rsi, %r12
movl %edi, %r15d
callq 0x7d2c
movq %rax, %rbx
xorl %edi, %edi
testq %rax, %rax
setne %dil
callq 0x6fd4
vxorps %xmm0, %xmm0, %xmm0
leaq -0xa8(%rbp), %rcx
vmovups %ymm0, 0x30(%rcx)
vmovups %ymm0, 0x10(%rcx)
leaq 0x15ec(%rip), %rax      # 0x7d71
movq %rax, (%rcx)
movq %rbx, 0x8(%rcx)
leaq -0x30(%rbp), %rdx
andq $0x0, (%rdx)
movl %r15d, %edi
movq %r12, %rsi
xorl %r8d, %r8d
vzeroupper
callq 0xad84
movl %eax, %r14d
testl %eax, %eax
js 0x684a
leaq -0x2b0(%rbp), %rdi
xorl %r13d, %r13d
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x6200
movl %r14d, %eax
cmpq %r13, %rax
je 0x67df
movq (%r12,%r13,8), %rcx
movq %rcx, -0x2b0(%rbp,%r13,8)
incq %r13
jmp 0x67c9
andq $0x0, -0x2b0(%rbp,%rax,8)
leaq -0x58(%rbp), %rcx
andq $0x0, (%rcx)
movq -0x30(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movq $0x8, 0x10(%rcx)
leaq 0xb9(%rip), %rdx        # 0x68c0
movq %rdx, 0x18(%rcx)
leaq 0x145(%rip), %rdx       # 0x6957
movq %rdx, 0x20(%rcx)
subl %r14d, %r15d
leaq (%r12,%rax,8), %rsi
leaq -0x2b0(%rbp), %rdx
movl %r15d, %edi
callq 0x1036b
movl %eax, %r15d
movq -0x30(%rbp), %rdi
callq 0xacb8
movq %rbx, %rdi
callq 0x7eb0
testl %r15d, %r15d
js 0x6859
addl %r15d, %r14d
jmp 0x6861
callq 0x6876
movq %rbx, %rdi
callq 0x7eb0
jmp 0x6861
callq 0x6876
movl %r15d, %r14d
movl %r14d, %eax
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/map_test.c
// Function: kvmap_help_message
static void
kvmap_help_message(void)
{
  fprintf(stderr, "%s Usage: <stdout> <stderr> {api ... {rgen ... {pass ...}}}\n", __func__);
  kvmap_api_helper_message();
  maptest_passes_message();
  fprintf(stderr, "set MAP_TEST_PERF=y to enable perf recording\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x12775(%rip), %rbx     # 0x18ff8
movq (%rbx), %rdi
leaq 0xb7cb(%rip), %rsi      # 0x12058
leaq 0xb801(%rip), %rdx      # 0x12095
xorl %eax, %eax
callq 0x62f0
callq 0xacdf
callq 0x104aa
movq (%rbx), %rcx
leaq 0xb7f9(%rip), %rdi      # 0x120a8
pushq $0x2d
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6540
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/map_test.c
// Function: kvmap_worker
static void *
kvmap_worker(void * const ptr)
{
  struct maptest_worker_info * const info = (typeof(info))ptr;
  const u64 end_magic = info->end_magic;
  info->priv = malloc(2048);
  srandom_u64(info->seed);
  if (info->end_type == MAPTEST_END_TIME) {
    do {
      kvmap_mix_batch(info, 4096);
    } while (time_nsec() < end_magic);
  } else if (info->end_type == MAPTEST_END_COUNT) {
    u64 count = 0;
    do {
      const u64 nr = (end_magic - count) > 4096 ? 4096 : (end_magic - count);
      kvmap_mix_batch(info, nr);
      count += nr;
    } while (count < end_magic);
  }
  free(info->priv);
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %r15
movl $0x800, %edi            # imm = 0x800
callq 0x6390
movq %rax, 0x58(%rbx)
movq 0x20(%rbx), %rdi
callq 0x91ba
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x6926
cmpq $0x1, %rax
jne 0x693d
xorl %r12d, %r12d
movl $0x1000, %r13d          # imm = 0x1000
movq %r15, %r14
subq %r12, %r14
cmpq %r13, %r14
cmovaeq %r13, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6a26
addq %r14, %r12
cmpq %r15, %r12
jb 0x6904
jmp 0x693d
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
callq 0x6a26
callq 0x6cdb
cmpq %r15, %rax
jb 0x6926
movq 0x58(%rbx), %rdi
callq 0x6060
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/map_test.c
// Function: kvmap_analyze
static bool
kvmap_analyze(struct vctr * const va, const double dt, struct damp * const damp, char * const out)
{
  u64 v[8];
  for (u64 i = 0; i < 8; i++) {
    v[i] = vctr_get(va, i);
  }

  const u64 nrop = v[XSA] + v[XDA] + v[XGA] + v[XPA];
  const double mops = ((double)nrop) / (dt * 1.0e6);
  const bool done = damp_add_test(damp, mops);
  const double havg = damp_average(damp);
  const char * const pat = " set %"PRIu64" %"PRIu64" del %"PRIu64" %"PRIu64
      " get %"PRIu64" %"PRIu64" pro %"PRIu64" %"PRIu64" mops %.4lf havg %.4lf\n";
  sprintf(out, pat, v[XSA], v[XSS], v[XDA], v[XDS], v[XGA], v[XGS], v[XPA], v[XPS], mops, havg);
  return done;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, -0x40(%rbp)
movq %rsi, %r14
vmovsd %xmm0, -0x30(%rbp)
movq %rdi, %r15
xorl %r12d, %r12d
cmpq $0x8, %r12
je 0x6995
movq %r15, %rdi
movq %r12, %rsi
callq 0x911c
movq %rax, -0x80(%rbp,%r12,8)
incq %r12
jmp 0x697a
movq -0x80(%rbp), %r12
movq -0x70(%rbp), %r15
movq -0x60(%rbp), %rbx
movq -0x50(%rbp), %r13
leaq (%rbx,%r13), %rcx
addq %r15, %rcx
addq %r12, %rcx
vcvtusi2sd %rcx, %xmm1, %xmm0
vmovsd -0x30(%rbp), %xmm1
vmulsd 0xb646(%rip), %xmm1, %xmm1 # 0x12008
vdivsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, -0x38(%rbp)
movq %r14, %rdi
callq 0x8f75
movb %al, -0x30(%rbp)
movq %r14, %rdi
callq 0x8e82
vmovapd %xmm0, %xmm1
movq -0x78(%rbp), %rcx
movq -0x68(%rbp), %r9
leaq 0xb61f(%rip), %rsi      # 0x12010
movq -0x40(%rbp), %rdi
movq %r12, %rdx
movq %r15, %r8
vmovsd -0x38(%rbp), %xmm0
movb $0x2, %al
pushq -0x48(%rbp)
pushq %r13
pushq -0x58(%rbp)
pushq %rbx
callq 0x6510
addq $0x20, %rsp
movb -0x30(%rbp), %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wuxb45[P]SLB/map_test.c
// Function: kvmap_mix_batch
static void
kvmap_mix_batch(const struct maptest_worker_info * const info, const u64 nr)
{
  struct kvmap_api * const api = (typeof(api))info->api;
  struct kv * const kv = (typeof(kv))info->priv;
  struct kv * const out = (typeof(out))(((u8*)info->priv)+384);
  struct vctr * const v = info->vctr;
  rgen_next_func next = info->rgen_next;

  for (u64 i = 0; i < nr; i++) {
    const u64 x = next(info->gen);
    kv_refill(kv, &x, sizeof(x), "", 0);
    const u64 y = random_u64() % 100lu;
    if (y < info->pset) { // SET
      vctr_add1(v, XSA);
      kv->vlen = info->vlen;
      if (api->set(api->map, kv)) vctr_add1(v, XSS);
    } else if (y < info->pdel) { // DEL
      vctr_add1(v, XDA);
      if (api->del(api->map, kv)) vctr_add1(v, XDS);
    } else if (y < info->pget) { // GET
      vctr_add1(v, XGA);
      if (api->get(api->map, kv, out)) vctr_add1(v, XGS);
    } else { // PROBE
      vctr_add1(v, XPA);
      if (api->probe(api->map, kv)) vctr_add1(v, XPS);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq 0x18(%rdi), %rax
movq %rax, -0x38(%rbp)
movq 0x58(%rdi), %r15
leaq 0x180(%r15), %rax
movq %rax, -0x30(%rbp)
movq 0x60(%rdi), %r13
subq $0x1, %rbx
jb 0x6b3d
movq 0x10(%r14), %rdi
callq *-0x38(%rbp)
movq %rax, -0x40(%rbp)
movq %r15, %rdi
leaq -0x40(%rbp), %rsi
pushq $0x8
popq %rdx
leaq 0xbd2b(%rip), %rcx      # 0x127ad
xorl %r8d, %r8d
callq 0xa925
callq 0x7e93
xorl %edx, %edx
pushq $0x64
popq %rcx
divq %rcx
cmpq 0x30(%r14), %rdx
jae 0x6abf
movq %r13, %rdi
xorl %esi, %esi
callq 0x90da
movl 0x28(%r14), %eax
movl %eax, 0xc(%r15)
movq (%r12), %rdi
movq %r15, %rsi
callq *0x18(%r12)
pushq $0x1
jmp 0x6b27
cmpq 0x38(%r14), %rdx
jae 0x6ae0
movq %r13, %rdi
pushq $0x2
popq %rsi
callq 0x90da
movq (%r12), %rdi
movq %r15, %rsi
callq *0x20(%r12)
pushq $0x3
jmp 0x6b27
cmpq 0x40(%r14), %rdx
jae 0x6b0e
movq %r13, %rdi
pushq $0x4
popq %rsi
callq 0x90da
movq (%r12), %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq *0x8(%r12)
pushq $0x5
popq %rsi
testq %rax, %rax
jne 0x6b30
jmp 0x6a5c
movq %r13, %rdi
pushq $0x6
popq %rsi
callq 0x90da
movq (%r12), %rdi
movq %r15, %rsi
callq *0x10(%r12)
pushq $0x7
popq %rsi
testb %al, %al
je 0x6a5c
movq %r13, %rdi
callq 0x90da
jmp 0x6a5c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/openshmem-org[P]openshmem-examples/c/cswap.c
// Function: main
int
main()
{
    static int race_winner = -1;
    int oldval;
    int me;

    shmem_init();
    me = shmem_my_pe();

    oldval = shmem_int_atomic_compare_swap(&race_winner, -1, me, 0);

    if (oldval == -1) {
        printf("pe %d was first\n", me);
    }

    shmem_finalize();

    return 0;
}

// Assembly:
pushq %rbx
callq 0x1060
callq 0x1050
movl %eax, %ebx
leaq 0x2ec0(%rip), %rdi      # 0x4050
pushq $-0x1
popq %rsi
movl %eax, %edx
xorl %ecx, %ecx
callq 0x1070
cmpl $-0x1, %eax
jne 0x11b1
leaq 0xe5c(%rip), %rdi       # 0x2004
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
callq 0x1040
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/cktan[P]tomlc99/toml_sample.c
// Function: main
int main() {
  FILE *fp;
  char errbuf[200];

  // 1. Read and parse toml file
  fp = fopen("sample.toml", "r");
  if (!fp) {
    fatal("cannot open sample.toml - ", strerror(errno));
  }

  toml_table_t *conf = toml_parse_file(fp, errbuf, sizeof(errbuf));
  fclose(fp);

  if (!conf) {
    fatal("cannot parse - ", errbuf);
  }

  // 2. Traverse to a table.
  toml_table_t *server = toml_table_in(conf, "server");
  if (!server) {
    fatal("missing [server]", "");
  }

  // 3. Extract values
  toml_datum_t host = toml_string_in(server, "host");
  if (!host.ok) {
    fatal("cannot read server.host", "");
  }

  toml_array_t *portarray = toml_array_in(server, "port");
  if (!portarray) {
    fatal("cannot read server.port", "");
  }

  printf("host: %s\n", host.u.s);
  printf("port: ");
  for (int i = 0;; i++) {
    toml_datum_t port = toml_int_at(portarray, i);
    if (!port.ok)
      break;
    printf("%d ", (int)port.u.i);
  }
  printf("\n");

  // 4. Free memory
  free(host.u.s);
  toml_free(conf);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
leaq 0x3d22(%rip), %rdi      # 0x5004
leaq 0x425e(%rip), %rsi      # 0x5547
callq 0x1180
testq %rax, %rax
je 0x13de
movq %rax, %r14
movq %rsp, %rsi
movq %rax, %rdi
movl $0xc8, %edx
callq 0x27fc
movq %rax, %rbx
movq %r14, %rdi
callq 0x1090
testq %rbx, %rbx
je 0x13f9
leaq 0x3d16(%rip), %rsi      # 0x503b
movq %rbx, %rdi
callq 0x2bff
testq %rax, %rax
je 0x1408
movq %rax, %r15
leaq 0x3d26(%rip), %rsi      # 0x5066
movq %rax, %rdi
callq 0x3a10
testl %eax, %eax
je 0x1411
movq %rdx, %r14
leaq 0x3d24(%rip), %rsi      # 0x507e
movq %r15, %rdi
callq 0x2bb1
testq %rax, %rax
je 0x141a
movq %rax, %r15
leaq 0x3d0e(%rip), %rdi      # 0x5083
movq %r14, %rsi
xorl %eax, %eax
callq 0x10c0
leaq 0x3d07(%rip), %rdi      # 0x508d
xorl %eax, %eax
callq 0x10c0
leaq 0x3d00(%rip), %r12      # 0x5094
xorl %ebp, %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0x3898
testl %eax, %eax
je 0x13b4
movq %r12, %rdi
movl %edx, %esi
xorl %eax, %eax
callq 0x10c0
incl %ebp
jmp 0x1396
pushq $0xa
popq %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x27f7
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1050
movl (%rax), %edi
callq 0x11a0
leaq 0x3c1f(%rip), %rdi      # 0x5010
movq %rax, %rsi
callq 0x142d
leaq 0x3c2b(%rip), %rdi      # 0x502b
movq %rsp, %rsi
callq 0x142d
leaq 0x3c33(%rip), %rdi      # 0x5042
jmp 0x1421
leaq 0x3c3b(%rip), %rdi      # 0x5053
jmp 0x1421
leaq 0x3c4a(%rip), %rdi      # 0x506b
leaq 0x420d(%rip), %rsi      # 0x5635
callq 0x142d
// File: /workspace/github_c_makefile_star2_O2/aparrish[P]rwet-examples-c/forfinder.c
// Function: main
int main(int argc, char** argv) {
	char* target_pos;
	char* line = NULL;
	int len;

	if (argc != 2) {
		fprintf(stderr, "please supply target string\n");
		exit(-1);
	}

	while (!feof(stdin)) {
		len = ap_getline(&line, stdin);
		target_pos = strstr(line, argv[1]);
		if (target_pos) printf("%s", target_pos);
		free(line);
	}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
andq $0x0, 0x8(%rsp)
cmpl $0x2, %edi
jne 0x1245
movq %rsi, %rbx
movq 0x2dfa(%rip), %r13      # 0x3fd8
leaq 0x8(%rsp), %r14
leaq 0xe37(%rip), %r15       # 0x2021
movq (%r13), %rdi
callq 0x1050
testl %eax, %eax
jne 0x1235
movq (%r13), %rsi
movq %r14, %rdi
callq 0x126c
movq 0x8(%rsp), %r12
movq 0x8(%rbx), %rsi
movq %r12, %rdi
callq 0x10b0
testq %rax, %rax
je 0x122b
movq %r15, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x1040
movq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x1030
jmp 0x11ea
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x2dac(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xdae(%rip), %rdi       # 0x2004
pushq $0x1c
popq %rsi
pushq $0x1
popq %rdx
callq 0x1090
pushq $-0x1
popq %rdi
callq 0x1080
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/hansvanstaveren[P]BigDeal/rmd160.c
// Function: MDfinish
void MDfinish(dword *MDbuf, byte *strptr, dword lswlen, dword mswlen)
{
   unsigned int i;                                 /* counter       */
   dword        X[16];                             /* message words */

   memset(X, 0, 16*sizeof(dword));

   /* put bytes from strptr into X */
   for (i=0; i<(lswlen&63); i++) {
      /* byte i goes into word X[i div 4] at pos.  8*(i mod 4)  */
      X[i>>2] ^= (dword) *strptr++ << (8 * (i&3));
   }

   /* append the bit m_n == 1 */
   X[(lswlen>>2)&15] ^= (dword)1 << (8*(lswlen&3) + 7);

   if ((lswlen & 63) > 55) {
      /* length goes to next block */
      compress(MDbuf, X);
      memset(X, 0, 16*sizeof(dword));
   }

   /* append length in bits*/
   X[14] = lswlen << 3;
   X[15] = (lswlen >> 29) | (mswlen << 3);
   compress(MDbuf, X);

   return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebx
movl %edx, %r15d
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl %edx, %eax
andl $0x3f, %eax
xorl %edx, %edx
xorl %edi, %edi
cmpl %edi, %eax
je 0x3644
movzbl (%rsi,%rdi), %r8d
movl %edx, %ecx
andb $0x18, %cl
shll %cl, %r8d
movl %edi, %ecx
andl $-0x4, %ecx
xorl %r8d, (%rsp,%rcx)
incq %rdi
addl $0x8, %edx
jmp 0x3622
leal (,%r15,8), %ebp
movl $0x80, %edx
movl %ebp, %ecx
shll %cl, %edx
movl %r15d, %ecx
andl $0x3c, %ecx
xorl %edx, (%rsp,%rcx)
cmpl $0x38, %eax
jb 0x368b
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x22fe
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq %rsp, %rsi
movl %ebp, 0x38(%rsi)
shldl $0x3, %r15d, %ebx
movl %ebx, 0x3c(%rsi)
movq %r14, %rdi
callq 0x22fe
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/hansvanstaveren[P]BigDeal/mp.c
// Function: mp96_add
int
mp96_add(byte *b,byte *b1,byte *b2)
/*
 * Computes b=b1+b2
 * returns carry bit signifying overflow
 */
{
	int i;
	unsigned int h,carry;

	carry = 0;
	for (i=L-1; i>=0; i--) {
		h = b1[i]+b2[i]+carry;
		carry = h>=256 ? 1 : 0;
		b[i] = h;		/* Truncates to 8 bits automatically */
	}
	return carry;
}

// Assembly:
xorl %eax, %eax
pushq $0xb
popq %rcx
testl %ecx, %ecx
js 0x3706
movl %ecx, %r8d
movzbl (%rsi,%r8), %r9d
movzbl (%rdx,%r8), %r10d
addl %r9d, %eax
addl %r10d, %eax
xorl %r9d, %r9d
cmpl $0x100, %eax            # imm = 0x100
setae %r9b
movb %al, (%rdi,%r8)
decl %ecx
movl %r9d, %eax
jmp 0x36d8
retq
// File: /workspace/github_c_makefile_star2_O2/hansvanstaveren[P]BigDeal/mp.c
// Function: mp96_mul
void
mp96_mul(byte *b,byte *b1,byte *b2)
/*
 * Computes b=b1*b2
 * overflow goes undetected
 */
{
	int i,j;
	unsigned int h,carry;
	byte b1copy[L],b2copy[L],bpart[L];

	/*
	 * Make copies of input in case one of the inputs is also output
	 */
	mp96_assign(b1copy, b1);
	mp96_assign(b2copy, b2);

	/*
	 * Here if an input is also output the input gets overwritten
	 */
	mp96_zero(b);

	for (i=L-1; i>=0; i--) {
		for (j=L-1; j>i; j--)
			bpart[j] = 0;
		carry=0;
		for (j=i; j>=0; j--) {
			h = b1copy[i]*b2copy[L-1+j-i]+carry;
			carry = h/256;
			bpart[j] = h;
		}
		(void) mp96_add(b,b,bpart);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
movl 0x8(%rsi), %eax
movl %eax, 0x10(%rsp)
movq (%rdx), %rax
leaq 0x2b(%rsp), %r15
movq %rax, -0xb(%r15)
movl 0x8(%rdx), %eax
movl %eax, -0x3(%r15)
andl $0x0, 0x8(%rdi)
andq $0x0, (%rdi)
pushq $0xb
popq %r12
leaq 0x14(%rsp), %r14
movq %r12, %r13
testq %r13, %r13
js 0x37ec
movq %r12, %rax
cmpq %rax, %r13
jge 0x37ac
movl %eax, %ecx
movb $0x0, 0x14(%rsp,%rcx)
decq %rax
jmp 0x379b
xorl %ecx, %ecx
movq %r15, %rax
movq %r13, %rdx
testq %rdx, %rdx
js 0x37d9
movzbl 0x8(%rsp,%r13), %esi
movzbl (%rax), %edi
imull %esi, %edi
addl %ecx, %edi
movl %edi, %ecx
shrl $0x8, %ecx
movb %dil, 0x14(%rsp,%rdx)
decq %rdx
decq %rax
jmp 0x37b4
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x36d3
decq %r13
jmp 0x3793
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/hansvanstaveren[P]BigDeal/binomial.c
// Function: binomial_start
void
binomial_start(void)
/*
 * Precomputes all numbers (n over k) with k<=NCARDSPERHAND and
 * n<=NCARDSPERDECK.
 * Numbers are stored in pascal_triangle[][] with L bytes precision (96 bits)
 *
 * Calculation method is the addition from the top of the triangle
 * with the equation:
 * 	n_over_k(n,k) = n_over_k(n-1, k-1) + n_over_k(n-1, k)
 * except for some boundary condition situations
 */
{
	int i,j,min;

	for (i=0; i<=NCARDSPERDECK; i++) {
		if (i<NCARDSPERHAND)
			min = i;
		else
			min = NCARDSPERHAND;
		for (j=0; j<=min; j++) {
			if (i==j || j==0)
				mp96_one(pascal_triangle[i][j]);
			else
				mp96_add(pascal_triangle[i][j],
					   pascal_triangle[i-1][j],
					   pascal_triangle[i-1][j-1]);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x60d2(%rip), %r14      # 0x98e0
xorl %r15d, %r15d
pushq $0xd
popq %rbp
cmpq $0x35, %r15
je 0x3875
cmpl $0xd, %r15d
movl %ebp, %r12d
cmovbl %r15d, %r12d
movq %r14, %rbx
xorl %r13d, %r13d
cmpq %r12, %r13
ja 0x3869
cmpq %r13, %r15
setne %al
testq %r13, %r13
setne %cl
testb %cl, %al
jne 0x384a
movq %rbx, %rdi
callq 0x36b9
jmp 0x3860
leaq -0xa8(%rbx), %rsi
leaq -0xb4(%rbx), %rdx
movq %rbx, %rdi
callq 0x36d3
incq %r13
addq $0xc, %rbx
jmp 0x382b
incq %r15
addq $0xa8, %r14
jmp 0x3814
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hansvanstaveren[P]BigDeal/main.c
// Function: readline
static int
readline(FILE *ifile, char *buf, int len)
/*
 * Read line into buf
 * Check for length, discard trailing \n
 */
{
	char *eol;

	if(fgets(buf, len, ifile) == NULL)
		return 0;
	eol = strchr(buf, '\n');
	if (eol)
		*eol = 0;
	return 1;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rax
movq %rsi, %rdi
movl %edx, %esi
movq %rax, %rdx
callq 0x2130
testq %rax, %rax
je 0x3cc5
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x20b0
movq %rax, %rcx
pushq $0x1
popq %rax
testq %rcx, %rcx
je 0x3cc7
movb $0x0, (%rcx)
jmp 0x3cc7
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hansvanstaveren[P]BigDeal/main.c
// Function: read_init_file
void
read_init_file(char *ifname, int write_when_absent)
/*
 * Read init file
 */
{
	FILE *ifile;
	char buf[MESSLEN+LONGESTKEYWORD];
	char *eqptr;
	struct ifrecord *ifrp;

	ifile = fopen(ifname, "r");
	if (ifile == NULL) {
		if (write_when_absent)
			write_init_file(ifname);
		return;
	}
	while (readline(ifile, buf, MESSLEN+LONGESTKEYWORD)) {
		if (buf[0] == 0)
			continue;		/* empty line */
		if (strcmp(buf, init_header)==0)
			continue;		/* header for Windows routines */
		if (buf[0] == '[')
			break;			/* end of our stuff */
		eqptr = strchr(buf, '=');
		if (eqptr == 0) {
			fprintf(stderr, "Line '%s' does not contain =\n", buf);
			fprintf(stderr, "Suggest rerun program with -R flag\n");
			continue;
		}
		*eqptr++ = 0;
		for (ifrp=init_file; ifrp->if_keyword; ifrp++) {
			if (strcmp(ifrp->if_keyword, buf)==0) {
				strcpy(ifrp->if_value, eqptr);
				break;
			}
		}
		if (!ifrp->if_keyword) {
			fprintf(stderr, "Keyword %s in init_file unknown\n", buf);
			fprintf(stderr, "Suggest rerun program with -R flag\n");
		}
	}
	fclose(ifile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0x28f7(%rip), %rsi      # 0x65da
callq 0x2190
testq %rax, %rax
je 0x3de9
movq %rax, %rbx
movq %rsp, %r14
pushq $0x78
popq %rbp
leaq 0x559f(%rip), %r15      # 0x92a0
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3c91
testl %eax, %eax
je 0x3dd2
movb (%rsp), %r12b
testb %r12b, %r12b
je 0x3d01
movq %r14, %rdi
movq %r15, %rsi
callq 0x2140
testl %eax, %eax
je 0x3d01
cmpb $0x5b, %r12b
je 0x3dd2
movq %r14, %rdi
pushq $0x3d
popq %rsi
callq 0x20b0
leaq 0x2388(%rip), %rsi      # 0x60d2
testq %rax, %rax
je 0x3da2
movq %rax, %r13
incq %r13
movb $0x0, (%rax)
leaq 0x5501(%rip), %r12      # 0x9260
movq (%r12), %rdi
testq %rdi, %rdi
je 0x3d9b
movq %r14, %rsi
callq 0x2140
testl %eax, %eax
je 0x3d7a
addq $0x10, %r12
jmp 0x3d5f
movq 0x8(%r12), %rdi
movq %r13, %rsi
callq 0x2050
cmpq $0x0, (%r12)
leaq 0x2381(%rip), %rsi      # 0x6114
jne 0x3d01
jmp 0x3da2
leaq 0x2372(%rip), %rsi      # 0x6114
movq 0x5247(%rip), %r12      # 0x8ff0
movq (%r12), %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2170
movq (%r12), %rcx
leaq 0x232e(%rip), %rdi      # 0x60f0
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x21e0
jmp 0x3d01
movq %rbx, %rdi
callq 0x2080
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
je 0x3dda
movq %r14, %rdi
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ab4
// File: /workspace/github_c_makefile_star2_O2/hansvanstaveren[P]BigDeal/main.c
// Function: setboards
void
setboards(char *a) {
	char *chptr;

	chptr =strchr(a,'-');
	if (chptr) {
		*chptr++ = 0;
		parameters.pp_lowboard = atoi(a);
		parameters.pp_highboard = atoi(chptr);
	} else {
		parameters.pp_lowboard = 1;
		parameters.pp_highboard = atoi(a);
	}
	parameters.pp_nboards =
	    parameters.pp_highboard - parameters.pp_lowboard + 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2d
popq %rsi
callq 0x20b0
testq %rax, %rax
je 0x3e3a
movq %rax, %r14
incq %r14
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x21b0
movl %eax, %ebx
movl %eax, 0x7d80(%rip)      # 0xbbb0
movq %r14, %rdi
callq 0x21b0
jmp 0x3e4f
movl $0x1, 0x7d6c(%rip)      # 0xbbb0
movq %rbx, %rdi
callq 0x21b0
pushq $0x1
popq %rbx
movl %eax, 0x7d5f(%rip)      # 0xbbb4
subl %ebx, %eax
incl %eax
movl %eax, 0x7d59(%rip)      # 0xbbb8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hansvanstaveren[P]BigDeal/main.c
// Function: RMDhash
static byte *
RMDhash(byte *value, int length)
/*
 * Hashes value of length bytes using RIPEMD160
 *
 * Returns pointer to 20 bytes hashcode
 */
{
	dword         MDbuf[RMDdwords];		/* contains (A, B, C, D(, E)) */
	dword	      X[16];			/* current 16 word chunk      */
	static byte   hashcode[RMDbytes];	/* for final hash-value       */
	unsigned int  i;			/* counter                    */
	int	      nbytes;			/* bytes not yet processed    */

	/* initialize */
	MDinit(MDbuf);

	/* Process value in 16-word chunks */
	for (nbytes=length; nbytes>=64; nbytes-=64) {
		for (i=0; i<16; i++) {
			X[i] = BYTES_TO_DWORD(value);
			value += 4;
		}
		compress(MDbuf, X);
	}
		
	/* finish: */
	MDfinish(MDbuf, value, length, 0);

	for (i=0; i<RMDbytes; i+=4) {
		hashcode[i]   =  MDbuf[i>>2];        /* implicit cast to byte */
		hashcode[i+1] = (MDbuf[i>>2] >>  8); /*  extracts the 8 least */
		hashcode[i+2] = (MDbuf[i>>2] >> 16); /*  significant bits.    */
		hashcode[i+3] = (MDbuf[i>>2] >> 24);
	}

	return (byte *)hashcode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x22ec
leaq 0x20(%rsp), %r12
movl %ebx, %ebp
cmpl $0x40, %ebp
jl 0x430b
xorl %r13d, %r13d
cmpq $0x40, %r13
je 0x42f8
movl (%r14,%r13), %eax
movl %eax, 0x20(%rsp,%r13)
addq $0x4, %r13
jmp 0x42e3
movq %r15, %rdi
movq %r12, %rsi
callq 0x22fe
addl $-0x40, %ebp
addq %r13, %r14
jmp 0x42db
movq %rsp, %rdi
xorl %r15d, %r15d
movq %r14, %rsi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0x35ef
leaq 0x78dc(%rip), %rax      # 0xbc00
cmpq $0x13, %r15
ja 0x4338
movl (%rsp,%r15), %ecx
movl %ecx, (%r15,%rax)
addq $0x4, %r15
jmp 0x4324
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop