LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/developer_cmds/ctags/print.c
// Function: put_entries
void
put_entries(node)
	NODE	*node;
{

	if (node->left)
		put_entries(node->left);
	if (vflag)
		printf("%s %s %d\n",
		    node->entry, node->file, (node->lno + 63) / 64);
	else if (xflag)
		printf("%-16s%4d %-16s %s\n",
		    node->entry, node->lno, node->file, node->pat);
	else
		fprintf(outf, "%s\t%s\t%c^%s%c\n",
		    node->entry, node->file, searchar, node->pat, searchar);
	if (node->right)
		put_entries(node->right);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3699(%rip), %r13      # 0x6148
leaq 0x3696(%rip), %rbp      # 0x614c
leaq 0x17ae(%rip), %r14      # 0x426b
leaq 0x1794(%rip), %r15      # 0x4258
leaq 0x1783(%rip), %r12      # 0x424e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2ad8
callq 0x2a9a
cmpl $0x0, (%r13)
je 0x2b04
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movl 0x28(%rbx), %ecx
leal 0x3f(%rcx), %eax
addl $0x7e, %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x6, %ecx
movq %r12, %rdi
xorl %eax, %eax
callq 0x1090
jmp 0x2b54
cmpl $0x0, (%rbp)
je 0x2b25
movl 0x28(%rbx), %edx
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rcx
movq 0x20(%rbx), %r8
movq %r15, %rdi
xorl %eax, %eax
callq 0x1090
jmp 0x2b54
leaq 0x363c(%rip), %rax      # 0x6168
movq (%rax), %rdi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x35de(%rip), %rax      # 0x611c
movsbl (%rax), %r8d
movq 0x20(%rbx), %r9
movl %r8d, (%rsp)
movq %r14, %rsi
xorl %eax, %eax
callq 0x1110
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2acb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/developer_cmds/ctags/tree.c
// Function: pfnote
void
pfnote(name, ln)
	char	*name;
	int	ln;
{
	NODE	*np;
	char	*fp;
	char	nbuf[MAXTOKEN];

	/*NOSTRICT*/
	if (!(np = (NODE *)malloc(sizeof(NODE)))) {
		warnx("too many entries to sort");
		put_entries(head);
		free_tree(head);
		/*NOSTRICT*/
		if (!(head = np = (NODE *)malloc(sizeof(NODE))))
			err(1, "out of space");
	}
	if (!xflag && !strcmp(name, "main")) {
		if (!(fp = strrchr(curfile, '/')))
			fp = curfile;
		else
			++fp;
		(void)sprintf(nbuf, "M%s", fp);
		fp = strrchr(nbuf, '.');
		if (fp && !fp[2])
			*fp = EOS;
		name = nbuf;
	}
	if (!(np->entry = strdup(name)))
		err(1, "strdup");
	np->file = curfile;
	np->lno = ln;
	np->left = np->right = 0;
	if (!(np->pat = strdup(lbuf)))
		err(1, "strdup");
	if (!head)
		head = np;
	else
		add_node(np, head);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %esi, %ebx
movq %rdi, %r15
movl $0x30, %edi
callq 0x1140
testq %rax, %rax
jne 0x2bd0
leaq 0x16e1(%rip), %rdi      # 0x427a
xorl %eax, %eax
callq 0x10a0
leaq 0x35b9(%rip), %r12      # 0x6160
movq (%r12), %rdi
callq 0x2a9a
movq (%r12), %rdi
callq 0x2cde
movl $0x30, %edi
callq 0x1140
movq %rax, (%r12)
testq %rax, %rax
je 0x2cd5
movq %rax, %r14
leaq 0x3572(%rip), %rax      # 0x614c
cmpl $0x0, (%rax)
jne 0x2bf2
leaq 0x16ba(%rip), %rsi      # 0x42a0
movq %r15, %rdi
callq 0x1100
testl %eax, %eax
je 0x2c64
movq %r15, %rdi
callq 0x11c0
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x2cc2
leaq 0x354a(%rip), %rax      # 0x6158
movq (%rax), %rax
movq %rax, 0x18(%r14)
movl %ebx, 0x28(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
leaq 0x3a59(%rip), %rdi      # 0x6680
callq 0x11c0
movq %rax, 0x20(%r14)
testq %rax, %rax
je 0x2cc2
leaq 0x3520(%rip), %rax      # 0x6160
movq (%rax), %rsi
testq %rsi, %rsi
je 0x2c52
movq %r14, %rdi
callq 0x2d07
jmp 0x2c55
movq %r14, (%rax)
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x34ed(%rip), %rax      # 0x6158
movq (%rax), %r15
movq %r15, %rdi
movl $0x2f, %esi
callq 0x10c0
leaq 0x1(%rax), %rdx
testq %rax, %rax
cmoveq %r15, %rdx
leaq 0x1618(%rip), %rsi      # 0x42a5
movq %rsp, %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x1190
movq %r15, %rdi
movl $0x2e, %esi
callq 0x10c0
testq %rax, %rax
je 0x2bf2
cmpb $0x0, 0x2(%rax)
jne 0x2bf2
movb $0x0, (%rax)
jmp 0x2bf2
leaq 0x15e0(%rip), %rsi      # 0x42a9
movl $0x1, %edi
xorl %eax, %eax
callq 0x1130
leaq 0x15b7(%rip), %rsi      # 0x4293
jmp 0x2cc9
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/developer_cmds/ctags/tree.c
// Function: free_tree
static void
free_tree(node)
	NODE	*node;
{
	while (node) {
		if (node->right)
			free_tree(node->right);
		free(node);
		node = node->left;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x2d06
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2cf5
callq 0x2cde
movq %rbx, %rdi
callq 0x1030
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x2ce7
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/developer_cmds/ctags/tree.c
// Function: add_node
static void
add_node(node, cur_node)
	NODE	*node,
		*cur_node;
{
	int	dif;

	dif = strcmp(node->entry, cur_node->entry);
	if (!dif) {
		if (node->file == cur_node->file) {
			if (!wflag)
				fprintf(stderr, "Duplicate entry in file %s, line %d: %s\nSecond entry ignored\n", node->file, lineno, node->entry);
			return;
		}
		if (!cur_node->been_warned)
			if (!wflag)
				fprintf(stderr, "Duplicate entry in files %s and %s: %s (Warning only)\n", node->file, cur_node->file, node->entry);
		cur_node->been_warned = YES;
	}
	else if (dif < 0)
		if (cur_node->left)
			add_node(node, cur_node->left);
		else
			cur_node->left = node;
	else if (cur_node->right)
		add_node(node, cur_node->right);
	else
		cur_node->right = node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq %rsi, %r15
movq 0x10(%r14), %rbx
movq 0x10(%rsi), %rsi
movq %rbx, %rdi
callq 0x1100
testl %eax, %eax
je 0x2d41
jns 0x2d32
movq (%r15), %rsi
testq %rsi, %rsi
jne 0x2d0f
jmp 0x2d68
movq 0x8(%r15), %rsi
testq %rsi, %rsi
jne 0x2d0f
movq %r14, 0x8(%r15)
jmp 0x2d79
movq 0x18(%r14), %rdx
movq 0x18(%r15), %rcx
cmpq %rcx, %rdx
je 0x2d6d
cmpb $0x0, 0x2c(%r15)
jne 0x2d61
leaq 0x33e8(%rip), %rax      # 0x6144
cmpl $0x0, (%rax)
je 0x2d7f
movb $0x1, 0x2c(%r15)
jmp 0x2d79
movq %r14, (%r15)
jmp 0x2d79
leaq 0x33d0(%rip), %rax      # 0x6144
cmpl $0x0, (%rax)
je 0x2d9c
popq %rbx
popq %r14
popq %r15
retq
movq 0x3272(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x155e(%rip), %rsi      # 0x42ee
movq %rbx, %r8
xorl %eax, %eax
callq 0x1110
jmp 0x2d61
movq 0x3255(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x38c3(%rip), %rax      # 0x6670
movl (%rax), %ecx
leaq 0x14fa(%rip), %rsi      # 0x42b0
movq %rbx, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1110
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/darwin-on-arm[P]darwin-sdk/developer_cmds/ctags/yacc.c
// Function: toss_yysec
void
toss_yysec()
{
	int	c;			/* read character */
	int	state;

	/*
	 * state == 0 : waiting
	 * state == 1 : received a newline
	 * state == 2 : received first %
	 * state == 3 : recieved second %
	 */
	lineftell = ftell(inf);
	for (state = 0; GETC(!=, EOF);)
		switch (c) {
		case '\n':
			++lineno;
			lineftell = ftell(inf);
			if (state == 3)		/* done! */
				return;
			state = 1;		/* start over */
			break;
		case '%':
			if (state)		/* if 1 or 2 */
				++state;	/* goto 3 */
			break;
		default:
			state = 0;		/* reset */
			break;
		}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x315e(%rip), %rbx      # 0x6150
movq (%rbx), %rdi
callq 0x1120
leaq 0x3e7f(%rip), %r14      # 0x6e80
movq %rax, (%r14)
xorl %r12d, %r12d
leaq 0x3662(%rip), %r15      # 0x6670
movq (%rbx), %rdi
callq 0x11d0
cmpl $0xa, %eax
je 0x303e
cmpl $0x25, %eax
je 0x302d
movl $0x0, %r12d
cmpl $-0x1, %eax
jne 0x300e
jmp 0x3058
leal 0x1(%r12), %eax
testl %r12d, %r12d
cmovel %r12d, %eax
movl %eax, %r12d
jmp 0x300e
incl (%r15)
movq (%rbx), %rdi
callq 0x1120
movq %rax, (%r14)
cmpl $0x3, %r12d
movl $0x1, %r12d
jne 0x300e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_20/dcl.c
// Function: main
int main(void)
{
  while (get_next_token() != EOF)
  {
    if (next_token == '\n')
    {
      ++line_nr;
      continue;
    }

    out[0] = '\0';

    if (is_valid_data_type(token))
    {
      strcpy(data_type, token);
    }
    else
    {
      Error = TRUE;
      printf("Error: invalid data type '%s' on line %zu.\n", token, line_nr);

      do
      {
        get_next_token();
      } while (next_token != '\n' && next_token != EOF);

      ++line_nr;
      continue;
    }

    dcl();

    if (next_token != '\n')
    {
      if (next_token == NAME)
      {
        printf("Syntax Error: '%s' unexpected on line %zu.\n", token, line_nr);
      }
      else
      {
        printf("Syntax Error: '%c' unexpected on line %zu.\n", next_token, line_nr);
      }

      do
      {
        get_next_token();
      } while (next_token != '\n' && next_token != EOF);
    }
    else if (!Error)
    {
      printf("%s:%s %s\n", name, out, data_type);
    }

    Error = FALSE;
    ++line_nr;
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x12f9
cmpl $-0x1, %eax
je 0x12e8
leaq 0x32f4(%rip), %rbx      # 0x44c0
leaq 0xe63(%rip), %r14       # 0x2036
leaq 0x3356(%rip), %r15      # 0x4530
leaq 0xe81(%rip), %r12       # 0x2062
leaq 0x2ee8(%rip), %r13      # 0x40d0
leaq 0xe9f(%rip), %rbp       # 0x208e
cmpl $0xa, 0x2ed6(%rip)      # 0x40cc
je 0x12d3
movb $0x0, 0x2ecd(%rip)      # 0x40d0
movq %rbx, %rdi
callq 0x13e2
testl %eax, %eax
je 0x1258
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1030
callq 0x143a
movl 0x2ea7(%rip), %esi      # 0x40cc
testl %esi, %esi
je 0x128d
cmpl $0xa, %esi
jne 0x12a3
cmpl $0x0, 0x2e93(%rip)      # 0x40c8
jne 0x12c9
leaq 0xe78(%rip), %rdi       # 0x20ba
leaq 0x3357(%rip), %rsi      # 0x45a0
movq %r13, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1050
jmp 0x12c9
movl $0x1, 0x2e66(%rip)      # 0x40c8
movq 0x2e57(%rip), %rdx      # 0x40c0
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
callq 0x12f9
movl 0x2e4b(%rip), %eax      # 0x40cc
cmpl $-0x1, %eax
je 0x12d3
cmpl $0xa, %eax
jne 0x1276
jmp 0x12d3
movq 0x2e2c(%rip), %rdx      # 0x40c0
movq %r12, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
jmp 0x12b4
movq 0x2e16(%rip), %rdx      # 0x40c0
movq %rbp, %rdi
xorl %eax, %eax
callq 0x1050
callq 0x12f9
movl 0x2e0d(%rip), %eax      # 0x40cc
cmpl $-0x1, %eax
je 0x12c9
cmpl $0xa, %eax
jne 0x12b4
movl $0x0, 0x2df5(%rip)      # 0x40c8
incq 0x2de6(%rip)            # 0x40c0
callq 0x12f9
cmpl $-0x1, %eax
jne 0x11ef
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_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_20/dcl.c
// Function: is_valid_data_type
int is_valid_data_type(const char *str)
{
  size_t nr_of_types = sizeof(data_types) / sizeof(data_types[0]);
  for (size_t i = 0; i < nr_of_types; ++i)
  {
    if (strcmp(data_types[i], str) == 0)
    {
      return TRUE;
    }
  }
  return FALSE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2c7f(%rip), %rdi      # 0x4070
movq %rbx, %rsi
callq 0x1060
testl %eax, %eax
je 0x142f
xorl %ecx, %ecx
leaq 0x2c6a(%rip), %r14      # 0x4070
movq %rcx, %r15
cmpq $0x7, %rcx
je 0x1424
movq 0x8(%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x1060
leaq 0x1(%r15), %rcx
testl %eax, %eax
jne 0x1406
xorl %eax, %eax
cmpq $0x7, %r15
setb %al
jmp 0x1434
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_20/dcl.c
// Function: dcl
void dcl(void)
{
  int nr_of_stars = 0;
  while (get_next_token() == '*')
  {
    ++nr_of_stars;
  }

  dir_dcl();

  while (nr_of_stars--)
  {
    strcat(out, " pointer to");
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0x1, %ebp
callq 0x12f9
decl %ebp
cmpl $0x2a, %eax
je 0x1443
callq 0x15f8
testl %ebp, %ebp
je 0x1481
leaq 0x2c71(%rip), %rbx      # 0x40d0
movabsq $0x7265746e696f7020, %r14 # imm = 0x7265746E696F7020
movq %rbx, %rdi
callq 0x1040
movq %r14, (%rax,%rbx)
movl $0x6f7420, 0x8(%rax,%rbx) # imm = 0x6F7420
incl %ebp
jne 0x1469
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_20/dcl.c
// Function: dir_dcl
void dir_dcl(void)
{
  if (next_token == PAREN_OPEN)
  {
    dcl();

    if (next_token != PAREN_CLOSE)
    {
      Error = TRUE;
      printf("Syntax Error: missing ')' on line %zu.\n", line_nr);
    }
  }
  else if (next_token == NAME)
  {
    strcpy(name, token);
  }
  else
  {
    Error = TRUE;
    printf("Syntax Error: expected name or (dcl) on line %zu.\n", line_nr);
  }

  while ((next_token = get_next_token()) == PARENS || next_token == BRACKETS || next_token == PAREN_OPEN)
  {
    if (next_token == PAREN_OPEN)
    {
      strcat(out, " function expecting");
      attr_dcl();
      strcat(out, " and returning");

      if (next_token != PAREN_CLOSE)
      {
        Error = TRUE;
        printf("Syntax Error: missing ')' on line %zu.\n", line_nr);

        if (next_token == '\n')
        {
          return;
        }
      }
    }
    else if (next_token == PARENS)
    {
      strcat(out, " function returning");
    }
    else if (next_token == BRACKETS)
    {
      strcat(out, " array[");
      strcat(out, token);
      strcat(out, "] of");
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2ac3(%rip), %eax      # 0x40cc
testl %eax, %eax
je 0x163a
cmpl $0x28, %eax
jne 0x164f
callq 0x143a
cmpl $0x29, 0x2aae(%rip)     # 0x40cc
je 0x166e
movl $0x1, 0x2a9e(%rip)      # 0x40c8
movq 0x2a8f(%rip), %rsi      # 0x40c0
leaq 0xaaa(%rip), %rdi       # 0x20e2
jmp 0x1667
leaq 0x2f5f(%rip), %rdi      # 0x45a0
leaq 0x2e78(%rip), %rsi      # 0x44c0
callq 0x1030
jmp 0x166e
movl $0x1, 0x2a6f(%rip)      # 0x40c8
movq 0x2a60(%rip), %rsi      # 0x40c0
leaq 0xaa3(%rip), %rdi       # 0x210a
xorl %eax, %eax
callq 0x1050
leaq 0x2a5b(%rip), %rbx      # 0x40d0
movabsq $0x5b796172726120, %r12 # imm = 0x5B796172726120
leaq 0x2e3a(%rip), %r14      # 0x44c0
movabsq $0x74657220646e6120, %r13 # imm = 0x74657220646E6120
movabsq $0x676e696e727574, %rbp # imm = 0x676E696E727574
leaq 0xa41(%rip), %r15       # 0x20e2
callq 0x12f9
movl %eax, 0x2a20(%rip)      # 0x40cc
cmpl $0x1, %eax
je 0x1753
cmpl $0x2, %eax
je 0x1723
cmpl $0x28, %eax
jne 0x1773
movq %rbx, %rdi
callq 0x1040
movups 0xa6b(%rip), %xmm0      # 0x213d
movups %xmm0, (%rax,%rbx)
movl $0x676e69, 0x10(%rax,%rbx) # imm = 0x676E69
callq 0x1782
movq %rbx, %rdi
callq 0x1040
movq %r13, (%rax,%rbx)
movq %rbp, 0x7(%rax,%rbx)
cmpl $0x29, 0x29d1(%rip)     # 0x40cc
je 0x16a1
movl $0x1, 0x29c1(%rip)      # 0x40c8
movq 0x29b2(%rip), %rsi      # 0x40c0
movq %r15, %rdi
xorl %eax, %eax
callq 0x1050
cmpl $0xa, 0x29ad(%rip)      # 0x40cc
jne 0x16a1
jmp 0x1773
movq %rbx, %rdi
callq 0x1040
movq %r12, (%rax,%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1080
movq %rbx, %rdi
callq 0x1040
movl $0x666f205d, (%rax,%rbx) # imm = 0x666F205D
movb $0x0, 0x4(%rax,%rbx)
jmp 0x16a1
movq %rbx, %rdi
callq 0x1040
movups 0x9fe(%rip), %xmm0      # 0x2160
movups %xmm0, (%rax,%rbx)
movl $0x676e69, 0x10(%rax,%rbx) # imm = 0x676E69
jmp 0x16a1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/OpenKMIP[P]libkmip/demos/demo_get.c
// Function: print_help
void
print_help(const char *app)
{
    printf("Usage: %s [flag value | flag] ...\n\n", app);
    printf("Flags:\n");
    printf("-a addr : the IP address of the KMIP server\n");
    printf("-c path : path to client certificate file\n");
    printf("-h      : print this help info\n");
    printf("-i id   : the ID of the symmetric key to retrieve\n");
    printf("-k path : path to client key file\n");
    printf("-p port : the port number of the KMIP server\n");
    printf("-r path : path to CA certificate file\n");
    printf("-s pass : the password for KMIP server authentication\n");
    printf("-u user : the username for KMIP server authentication\n");
}

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0x1ebc9(%rip), %rdi     # 0x21020
xorl %eax, %eax
callq 0x2040
leaq 0x1ee35(%rip), %rdi     # 0x2129a
callq 0x2210
leaq 0x1ee30(%rip), %rdi     # 0x212a1
callq 0x2210
leaq 0x1ee50(%rip), %rdi     # 0x212cd
callq 0x2210
leaq 0x1ee6e(%rip), %rdi     # 0x212f7
callq 0x2210
leaq 0x1ee81(%rip), %rdi     # 0x21316
callq 0x2210
leaq 0x1eea7(%rip), %rdi     # 0x21348
callq 0x2210
leaq 0x1eebd(%rip), %rdi     # 0x2136a
callq 0x2210
leaq 0x1eede(%rip), %rdi     # 0x21397
callq 0x2210
leaq 0x1eef8(%rip), %rdi     # 0x213bd
callq 0x2210
leaq 0x1ef22(%rip), %rdi     # 0x213f3
popq %rax
jmp 0x2210
// File: /workspace/github_c_makefile_star2_O1/OpenKMIP[P]libkmip/demos/demo_get.c
// Function: main
int
main(int argc, char **argv)
{
    char *server_address = NULL;
    char *server_port = NULL;
    char *client_certificate = NULL;
    char *client_key = NULL;
    char *ca_certificate = NULL;
    char *username = NULL;
    char *password = NULL;
    char *id = NULL;
    int help = 0;
    
    int error = parse_arguments(argc, argv, &server_address, &server_port, &client_certificate, &client_key, &ca_certificate, &username, &password, &id, &help);
    if(error)
    {
        return(error);
    }
    if(help)
    {
        print_help(argv[0]);
        return(0);
    }
    
    int result = use_mid_level_api(server_address, server_port, client_certificate, client_key, ca_certificate, username, password, id);
    return(result);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
xorl %eax, %eax
leaq 0x48(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x38(%rsp), %r8
movq %rax, (%r8)
leaq 0x30(%rsp), %r9
movq %rax, (%r9)
leaq 0x28(%rsp), %r10
movq %rax, (%r10)
leaq 0x20(%rsp), %r11
movq %rax, (%r11)
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
leaq 0xc(%rsp), %rax
movl $0x0, (%rax)
subq $0x8, %rsp
pushq %rax
pushq %r15
pushq %r14
pushq %r11
pushq %r10
callq 0x24d7
addq $0x30, %rsp
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x2c6a
cmpl $0x0, 0xc(%rsp)
je 0x2c74
movq (%rbx), %rdi
callq 0x244c
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %r9
pushq 0x10(%rsp)
pushq 0x20(%rsp)
callq 0x277c
addq $0x60, %rsp
jmp 0x2c6e
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190906_1MM1_INTRO_pista_prac01/segundos_a_formato.c
// Function: main
int main(int argc,char *argv[])
{
  int S,s,m,h;
  printf("Segundos: ");
  scanf("%d",&S);
  (!(S/60))?printf("%s:%s:%.2d\n","00","00",S):
((S/60)<60)?printf("%s:%.2d:%.2d\n","00",S/60,S%60):
printf("%.2d:%.2d:%.2d\n",S/3600,(S%3600)/60,(S%3600)%60);
  
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xeab(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1030
leaq 0xea8(%rip), %rdi       # 0x200f
leaq -0xc(%rbp), %rbx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
movslq (%rbx), %rcx
leal 0x3b(%rcx), %eax
cmpl $0x76, %eax
ja 0x119a
leaq 0xe8b(%rip), %rdi       # 0x2012
leaq 0xe90(%rip), %rdx       # 0x201e
movq %rdx, %rsi
xorl %eax, %eax
callq 0x1030
jmp 0x120a
cmpl $0xe0f, %ecx            # imm = 0xE0F
jg 0x11d5
imulq $-0x77777777, %rcx, %rdx # imm = 0x88888889
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %eax
shrl $0x1f, %eax
sarl $0x5, %edx
addl %eax, %edx
imull $0x3c, %edx, %eax
subl %eax, %ecx
leaq 0xe5c(%rip), %rdi       # 0x2021
leaq 0xe52(%rip), %rsi       # 0x201e
xorl %eax, %eax
callq 0x1030
jmp 0x120a
movl %ecx, %eax
movl $0x91a2b3c5, %esi       # imm = 0x91A2B3C5
imulq %rax, %rsi
shrq $0x2b, %rsi
imull $0xe10, %esi, %eax      # imm = 0xE10
subl %eax, %ecx
imulq $0x4444445, %rcx, %rdx  # imm = 0x4444445
shrq $0x20, %rdx
imull $0x3c, %edx, %eax
subl %eax, %ecx
leaq 0xe2c(%rip), %rdi       # 0x202f
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deepika9294[P]Threading-Library/many-one/test/search.c
// Function: binary_search
void* binary_search(void* arg) {
   int thread_part = part++;
   int mid;
   int start = thread_part * (MAX / 4); 
   int end = (thread_part + 1) * (MAX / 4);
   while (start < end && !is_found) { 
      mid = (end - start) / 2 + start;
      if (arr[mid] == key) {
         is_found = 1;
         break;
      }
      else if (arr[mid] > key)
         end = mid - 1;
      else
         start = mid + 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x2862(%rip), %eax      # 0x411c
leal 0x1(%rax), %edx
movl %edx, 0x2859(%rip)      # 0x411c
movl 0x284f(%rip), %ecx      # 0x4118
testl %ecx, %ecx
jne 0x1926
shll $0x2, %edx
shll $0x2, %eax
movl 0x27f7(%rip), %esi      # 0x40d0
leaq 0x27b0(%rip), %rdi      # 0x4090
movl %edx, %r9d
subl %eax, %r9d
movl %r9d, %r8d
shrl $0x1f, %r8d
addl %r9d, %r8d
sarl %r8d
addl %eax, %r8d
movslq %r8d, %r9
movl (%rdi,%r9,4), %r9d
cmpl %esi, %r9d
je 0x191c
jg 0x190c
incl %r8d
movl %r8d, %eax
jmp 0x1912
decl %r8d
movl %r8d, %edx
cmpl %edx, %eax
jge 0x1926
testl %ecx, %ecx
je 0x18e0
jmp 0x1926
movl $0x1, 0x27f2(%rip)      # 0x4118
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/deepika9294[P]Threading-Library/many-one/test/search.c
// Function: main
int main() {
   dthread_t threads[4];
   dthread_init();
   for (int i = 0; i < 4; i++)
      dthread_create(&threads[i],binary_search, NULL);
   for (int i = 0; i < 4; i++)
      dthread_join(threads[i], NULL); 

   //as we know key used is already in the array
   if (is_found == expected_result)
		printf(GREEN "\n**PASSED**: BINARY SEARCH test with 4 threads\n" NONE);
   else
		printf(RED "\n**FAILED**: BINARY SEARCH test with 4 threads\n" NONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
callq 0x11fc
xorl %r14d, %r14d
leaq -0x92(%rip), %rbx       # 0x18b0
leaq (%r14,%rbp), %rdi
addq $-0x30, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1505
addq $0x8, %r14
cmpq $0x20, %r14
jne 0x1942
xorl %ebx, %ebx
movq -0x30(%rbp,%rbx,8), %rdi
xorl %esi, %esi
callq 0x164e
incq %rbx
cmpq $0x4, %rbx
jne 0x1960
movl 0x279d(%rip), %eax      # 0x4118
cmpl 0x2753(%rip), %eax      # 0x40d4
leaq 0x6a9(%rip), %rax       # 0x2031
leaq 0x6df(%rip), %rdi       # 0x206e
cmoveq %rax, %rdi
xorl %eax, %eax
callq 0x1070
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O1/sgsfak[P]c-ocgeo/src/ocgeo.c
// Function: ocgeo_default_params
ocgeo_params_t ocgeo_default_params(void)
{

    ocgeo_params_t params = {0};
    params.proximity = ocgeo_invalid_point;
    params.bounds.southwest = ocgeo_invalid_point;
    params.bounds.northeast = ocgeo_invalid_point;
    return params;
}

// Assembly:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, (%rdi)
movups 0x5b58(%rip), %xmm0     # 0x7480
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/sgsfak[P]c-ocgeo/src/ocgeo.c
// Function: ocgeo_reverse
bool ocgeo_reverse(double lat, double lng, const char* api_key,
        ocgeo_params_t* params, ocgeo_response_t* response)
{
    sds q = sdsempty();
    q = sdscatprintf(q, "%.8F,%.8F", lat, lng);
    bool ok = do_request(false, q, api_key, params, response);
    sdsfree(q);
    return ok;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
callq 0x290b
leaq 0x5873(%rip), %rsi      # 0x75ad
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movb $0x2, %al
callq 0x2d46
movq %rax, %r12
xorl %edi, %edi
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x1948
movl %eax, %ebx
movq %r12, %rdi
callq 0x295d
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sgsfak[P]c-ocgeo/src/ocgeo.c
// Function: ocgeo_response_cleanup
void ocgeo_response_cleanup(ocgeo_response_t* r)
{
    if (r == NULL)
        return;

    ocgeo_result_t* result;
    foreach_ocgeo_result(result, r) {
        free(result->bounds);
        free(result->timezone);
        free(result->roadinfo);
        free(result->currency);
    }
    r->total_results = 0;
    free(r->results);
    r->results = NULL;
    cJSON_Delete(r->internal);
    r->internal = NULL;
	sdsfree(r->url);
	r->url = NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x1e1c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %r14
cmpl $0x0, 0x24(%rdi)
je 0x1de5
movq 0x8(%r14), %rdi
callq 0x11f8
movq 0xb8(%r14), %rdi
callq 0x11f8
movq 0xc0(%r14), %rdi
callq 0x11f8
movq 0xc8(%r14), %rdi
callq 0x11f8
addq $0xe8, %r14
movq 0x28(%rbx), %rdi
movslq 0x24(%rbx), %rax
imulq $0xe8, %rax, %rax
addq %rdi, %rax
cmpq %rax, %r14
jne 0x1d98
jmp 0x1de8
movq %r14, %rdi
movl $0x0, 0x24(%rbx)
callq 0x11f8
xorl %r14d, %r14d
movq %r14, 0x28(%rbx)
movq 0x30(%rbx), %rdi
callq 0x3c46
movq %r14, 0x30(%rbx)
movq 0x10(%rbx), %rdi
callq 0x295d
movq %r14, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sgsfak[P]c-ocgeo/src/ocgeo.c
// Function: ocgeo_response_get_str
const char* ocgeo_response_get_str(ocgeo_result_t* r, const char* path, bool* ok)
{
    cJSON* js = get_json_field(r->internal, path);
    if (js == NULL || cJSON_IsNull(js) || !cJSON_IsString(js)) {
        *ok = false;
        return NULL;
    }
    *ok = true;
    return js->valuestring;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0xe0(%rdi), %rdi
callq 0x1e66
testq %rax, %rax
je 0x1e44
movq %rax, %r14
movq %rax, %rdi
callq 0x5cf3
testl %eax, %eax
je 0x1e51
movb $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x3b92
testl %eax, %eax
je 0x1e44
movb $0x1, (%rbx)
movq 0x20(%r14), %rax
jmp 0x1e49
// File: /workspace/github_c_makefile_star2_O1/sgsfak[P]c-ocgeo/src/ocgeo.c
// Function: get_json_field
static
cJSON* get_json_field(cJSON* parent, const char* path)
{
    static const char* sep = ".";

    if (parent == NULL)
        return NULL;
    int n = 0;
    sds* fields = sdssplitlen(path, strlen(path), sep, 1, &n);
    if (fields == NULL)
        return NULL;

    cJSON* current = parent;
    for (int k = 0; k<n && current != NULL; ++k) {
        int index = str_to_maybe_int(fields[k]);
        if (index >= 0)
            current = cJSON_GetArrayItem(current, index);
        else
            current = cJSON_GetObjectItemCaseSensitive(current, fields[k]);
    }
    sdsfreesplitres(fields, n);
    return current;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1f7c
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %r15
movl $0x0, (%r15)
movq %rsi, %rdi
callq 0x1090
leaq 0x52e5(%rip), %rdx      # 0x717d
movq %r14, %rdi
movl %eax, %esi
movl $0x1, %ecx
movq %r15, %r8
callq 0x2f8f
testq %rax, %rax
je 0x1f7c
movq %rax, %r14
movl 0x4(%rsp), %esi
testl %esi, %esi
jle 0x1f72
xorl %r15d, %r15d
leaq 0x55d4(%rip), %r12      # 0x74a0
movq (%r14,%r15,8), %rsi
movslq -0x8(%rsi), %rcx
movl $0x0, %eax
testq %rcx, %rcx
jle 0x1f44
xorl %edx, %edx
xorl %eax, %eax
movzbl (%rsi,%rdx), %edi
leal (%rax,%rax,4), %r8d
leal (%rax,%r8,2), %eax
addl $-0x30, %edi
cmpl $0x9, %edi
ja 0x1f26
movslq (%r12,%rdi,4), %rdi
addq %r12, %rdi
jmpq *%rdi
incl %eax
jmp 0x1f2d
addl $0x4, %eax
jmp 0x1f2d
addl $0x9, %eax
jmp 0x1f2d
addl $0x2, %eax
jmp 0x1f2d
addl $0x3, %eax
jmp 0x1f2d
addl $0x7, %eax
jmp 0x1f2d
addl $0x5, %eax
jmp 0x1f2d
addl $0x6, %eax
jmp 0x1f2d
xorl %edi, %edi
jmp 0x1f30
addl $0x8, %eax
movb $0x1, %dil
testb %dil, %dil
je 0x1f3f
incq %rdx
cmpq %rdx, %rcx
jne 0x1ee2
jmp 0x1f44
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rbx, %rdi
testl %eax, %eax
js 0x1f54
movl %eax, %esi
callq 0x4997
jmp 0x1f59
callq 0x4a80
movq %rax, %rbx
incq %r15
movslq 0x4(%rsp), %rsi
cmpq %rsi, %r15
jge 0x1f72
testq %rbx, %rbx
jne 0x1ecc
movq %r14, %rdi
callq 0x3145
jmp 0x1f7e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sgsfak[P]c-ocgeo/src/ocgeo.c
// Function: ocgeo_response_get_int
int ocgeo_response_get_int(ocgeo_result_t* r, const char* path, bool* ok)
{
    cJSON* js = get_json_field(r->internal, path);
    if (js == NULL || cJSON_IsNull(js) || !cJSON_IsNumber(js)) {
        *ok = false;
        return 0;
    }
    *ok = true;
    return js->valueint;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0xe0(%rdi), %rdi
callq 0x1e66
testq %rax, %rax
je 0x1fb4
movq %rax, %r14
movq %rax, %rdi
callq 0x5cf3
testl %eax, %eax
je 0x1fc1
movb $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x5d02
testl %eax, %eax
je 0x1fb4
movb $0x1, (%rbx)
movl 0x28(%r14), %eax
jmp 0x1fb9
// File: /workspace/github_c_makefile_star2_O1/sgsfak[P]c-ocgeo/src/ocgeo.c
// Function: ocgeo_response_get_dbl
double ocgeo_response_get_dbl(ocgeo_result_t* r, const char* path, bool* ok)
{
    cJSON* js = get_json_field(r->internal, path);
    if (js == NULL || cJSON_IsNull(js) || !cJSON_IsNumber(js)) {
        *ok = false;
        return 0.0;
    }
    *ok = true;
    return js->valuedouble;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0xe0(%rdi), %rdi
callq 0x1e66
testq %rax, %rax
je 0x1ffd
movq %rax, %r14
movq %rax, %rdi
callq 0x5cf3
testl %eax, %eax
je 0x200b
movb $0x0, (%rbx)
xorps %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x5d02
testl %eax, %eax
je 0x1ffd
movb $0x1, (%rbx)
movsd 0x30(%r14), %xmm0
jmp 0x2003
// File: /workspace/github_c_makefile_star2_O1/stv0g[P]c11-queues/mpmc_test_fib.c
// Function: producer
int producer(void *ctx)
{
	//printf("producer\n"); //DELETEME
	struct mpmc_queue *q = (struct mpmc_queue *) ctx;
	
	srand((unsigned) time(0) + thread_get_id());
	size_t pause = rand() % 1000;

	/* Wait for global start signal */
	while (g_start == 0)
		thrd_yield();
	
		/* Wait for a random time */
	for (size_t i = 0; i != pause; i += 1)
		nop();
	
	/* Enqueue */
	for (unsigned long count = 0, n1 = 0, n2 = 1; count < N; count++) {
		fibs[count] = n1 + n2;
		
		void *fibptr = (void *) &fibs[count];
		
		if (!mpmc_queue_push(q, fibptr)) {
			printf("Queue push failed at count %lu\n", count);
			return -1;
		}
		
		n1 = n2; n2 = fibs[count];
	}
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
xorl %edi, %edi
callq 0x1090
leal -0x1(%rax), %edi
callq 0x1080
callq 0x10f0
movslq %eax, %rbx
imulq $0x10624dd3, %rbx, %rax # imm = 0x10624DD3
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x26, %rax
addl %ecx, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
subl %eax, %ebx
cmpl $0x0, 0x2e53(%rip)      # 0x40a0
jne 0x1256
callq 0x1070
jmp 0x1246
testl %ebx, %ebx
je 0x1264
movslq %ebx, %rax
pause
decq %rax
jne 0x125d
movl $0x1, %r13d
movb $0x1, %r15b
leaq 0x2e3c(%rip), %r14      # 0x40b0
xorl %ebx, %ebx
xorl %r12d, %r12d
leal (%rbx,%r13), %eax
movl %eax, (%r14)
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x16a7
movl %eax, %ebp
testl %eax, %eax
je 0x129a
movq %r13, %rbx
movl (%r14), %r13d
jmp 0x12ab
leaq 0xd63(%rip), %rdi       # 0x2004
movq %r12, %rsi
xorl %eax, %eax
callq 0x1060
testl %ebp, %ebp
je 0x12ce
cmpq $0x1312cff, %r12        # imm = 0x1312CFF
leaq 0x1(%r12), %rax
setb %r15b
addq $0x4, %r14
movq %rax, %r12
cmpq $0x1312d00, %rax        # imm = 0x1312D00
jne 0x1279
movzbl %r15b, %eax
andl $0x1, %eax
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stv0g[P]c11-queues/mpmc_test_fib.c
// Function: consumer
int consumer(void *ctx)
{
	//printf("consumer\n"); 	//DELETEME
	struct mpmc_queue *q = (struct mpmc_queue *) ctx;
	
	srand((unsigned) time(0) + thread_get_id());
	size_t pause = rand() % 1000;

	/* Wait for global start signal */
	while (g_start == 0)
		thrd_yield();
	
	/* Wait for a random time */
	for (size_t i = 0; i != pause; i += 1)
		nop();
	
	/* Dequeue */
	for (unsigned long count = 0, n1 = 0, n2 = 1; count < N; count++) {
		int fib = n1 + n2;
		int *pulled;
		
		while (!mpmc_queue_pull(q, (void **) &pulled)) {
			//printf("Queue empty: %d\n", temp);
			//return -1;
		}
		
		if (*pulled != fib) {
			printf("Pulled != fib\n");
			return -1;
		}		
		
		n1 = n2; n2 = fib;
	}
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x1090
leal -0x1(%rax), %edi
callq 0x1080
callq 0x10f0
movslq %eax, %r14
imulq $0x10624dd3, %r14, %rax # imm = 0x10624DD3
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x26, %rax
addl %ecx, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
subl %eax, %r14d
cmpl $0x0, 0x2d6e(%rip)      # 0x40a0
jne 0x133b
callq 0x1070
jmp 0x132b
testl %r14d, %r14d
je 0x134a
movslq %r14d, %rax
pause
decq %rax
jne 0x1343
movl $0x1, %ecx
movb $0x1, 0x7(%rsp)
xorl %edx, %edx
leaq 0x10(%rsp), %r14
xorl %r15d, %r15d
movq %rcx, %rbp
movq %rdx, 0x8(%rsp)
leaq (%rcx,%rdx), %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16ef
testl %eax, %eax
je 0x136a
movq 0x10(%rsp), %rax
movl (%rax), %r12d
cmpl %r13d, %r12d
jne 0x138e
movq %rbp, %rdx
movslq %r13d, %rcx
jmp 0x13a2
leaq 0xcff(%rip), %rdi       # 0x2094
callq 0x1040
movq %rbp, %rcx
movq 0x8(%rsp), %rdx
cmpl %r13d, %r12d
jne 0x13c2
cmpq $0x1312cff, %r15        # imm = 0x1312CFF
leaq 0x1(%r15), %rax
setb 0x7(%rsp)
movq %rax, %r15
cmpq $0x1312d00, %rax        # imm = 0x1312D00
jne 0x135e
movzbl 0x7(%rsp), %eax
andl $0x1, %eax
negl %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stv0g[P]c11-queues/mpmc_test_fib.c
// Function: test_single_threaded
int test_single_threaded(struct mpmc_queue *q)
{
	int resp, resc;
	g_start = 1;
	
	resp = producer(q);
	if (resp)
		printf("Enqueuing failed\n");
	
	resc = consumer(q);
	if (resc)
		printf("Consumer failed\n");
	
	if (resc || resp)
		printf("Single Thread Test Failed\n");
	else
		printf("Single Thread Test Complete\n");
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x1, 0x2cb4(%rip)      # 0x40a0
callq 0x1204
movl %eax, %ebx
testl %eax, %eax
je 0x1403
leaq 0xca4(%rip), %rdi       # 0x20a2
callq 0x1040
movq %r14, %rdi
callq 0x12e6
movl %eax, %ebp
testl %eax, %eax
je 0x141d
leaq 0xc9b(%rip), %rdi       # 0x20b3
callq 0x1040
orl %ebx, %ebp
leaq 0xc9d(%rip), %rax       # 0x20c3
leaq 0xcb2(%rip), %rdi       # 0x20df
cmoveq %rax, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stv0g[P]c11-queues/mpmc_test_fib.c
// Function: test_multi_threaded
int test_multi_threaded(struct mpmc_queue *q)
{
	thrd_t thrp, thrc;
	int resp, resc;
	
	g_start = 0;
	
	thrd_create(&thrp, consumer, q);	/** @todo Why producer thread runs earlier? */
	thrd_create(&thrc, producer, q);
	
	sleep(1);

	uint64_t start_tsc_time, end_tsc_time;

	start_tsc_time = rdtscp();
	g_start = 1;

	thrd_join(thrp, &resp);
	thrd_join(thrc, &resc);
	
	end_tsc_time = rdtscp();

	if (resc || resp)
		printf("Queue Test failed\n");
	else
		printf("Two-thread Test Complete\n");
	
	printf("cycles/op for rdtsc %lu\n", (end_tsc_time - start_tsc_time)/N);

	size_t used = mpmc_queue_available(q);
	if (used > 0)
		printf("%zu slots in use? There is something wrong with the test\n", used);
	
	int ret = mpmc_queue_destroy(q);
	if (ret)
		printf("Failed to destroy queue: %d\n", ret);
	
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x0, 0x2c49(%rip)      # 0x40a0
leaq -0x178(%rip), %rdx      # 0x12e6
leaq 0x18(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x10c0
leaq -0x273(%rip), %rdx      # 0x1204
leaq 0x10(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x10c0
movl $0x1, %edi
callq 0x10e0
rdtsc
shlq $0x20, %rdx
orq %rdx, %rax
movq %rax, %r14
movl $0x1, 0x2bf7(%rip)      # 0x40a0
movq (%r15), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x10d0
movq (%r15), %r13
movq (%r12), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x10d0
orl (%r15), %r13d
leaq 0xc3b(%rip), %rax       # 0x2112
leaq 0xc1b(%rip), %rdi       # 0x20f9
cmovneq %rax, %rdi
rdtsc
shlq $0x20, %rdx
orq %rdx, %rax
movq %rax, %r15
callq 0x1040
subq %r14, %r15
movabsq $-0x29406b2a1a85bd43, %rcx # imm = 0xD6BF94D5E57A42BD
movq %r15, %rax
mulq %rcx
shrq $0x18, %rdx
leaq 0xb13(%rip), %rdi       # 0x2024
movq %rdx, %rsi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x1695
testq %rax, %rax
je 0x1539
leaq 0xb0e(%rip), %rdi       # 0x203d
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x1679
testl %eax, %eax
je 0x1555
leaq 0xb2b(%rip), %rdi       # 0x2077
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stv0g[P]c11-queues/mpmc_queue.c
// Function: mpmc_queue_init
int mpmc_queue_init(struct mpmc_queue *q, size_t size, const struct memtype *mem)
{
	/* Queue size must be 2 exponent */
	if ((size < 2) || ((size & (size - 1)) != 0))
		return -1;

	q->mem = mem;
	q->buffer_mask = size - 1;
	q->buffer = memory_alloc(q->mem, sizeof(q->buffer[0]) * size);
	if (!q->buffer)
		return -2;
	
	for (size_t i = 0; i != size; i += 1)
		atomic_store_explicit(&q->buffer[i].sequence, i, memory_order_relaxed);

	atomic_store_explicit(&q->tail, 0, memory_order_relaxed);
	atomic_store_explicit(&q->head, 0, memory_order_relaxed);
	
	return 0;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x2, %rsi
jb 0x1678
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rcx
shrq %rcx
movabsq $0x5555555555555555, %rsi # imm = 0x5555555555555555
andq %rcx, %rsi
movq %r14, %rcx
subq %rsi, %rcx
movabsq $0x3333333333333333, %rsi # imm = 0x3333333333333333
movq %rcx, %rdi
andq %rsi, %rdi
shrq $0x2, %rcx
andq %rsi, %rcx
addq %rdi, %rcx
movq %rcx, %rsi
shrq $0x4, %rsi
addq %rcx, %rsi
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rsi, %rcx
movabsq $0x101010101010101, %rsi # imm = 0x101010101010101
imulq %rcx, %rsi
shrq $0x38, %rsi
cmpl $0x1, %esi
ja 0x1671
leaq -0x1(%r14), %rax
movq %rdx, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movq %r14, %rsi
shlq $0x4, %rsi
movq %rdx, %rdi
callq 0x17f8
movq %rax, 0x50(%rbx)
testq %rax, %rax
je 0x166c
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x50(%rbx), %rdx
movq %rcx, (%rdx,%rax)
incq %rcx
addq $0x10, %rax
cmpq %rcx, %r14
jne 0x163e
movq $0x0, 0x98(%rbx)
movq $0x0, 0xe0(%rbx)
xorl %eax, %eax
jmp 0x1671
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stv0g[P]c11-queues/mpmc_queue.c
// Function: mpmc_queue_push_many
int mpmc_queue_push_many(struct mpmc_queue *q, void *ptr[], size_t cnt)
{
	int ret;
	size_t i;

	for (i = 0; i < cnt; i++) {
		ret = mpmc_queue_push(q, ptr[i]);
		if (!ret)
			break;
	}
	
	return i;
}

// Assembly:
testq %rdx, %rdx
je 0x17ab
pushq %r14
pushq %rbx
xorl %ecx, %ecx
movq (%rsi,%rcx,8), %r9
movq 0x98(%rdi), %rax
movq %rax, %r8
movq 0x50(%rdi), %r10
movq 0x48(%rdi), %rbx
andq %rax, %rbx
shlq $0x4, %rbx
movq (%r10,%rbx), %r11
cmpq %rax, %r11
jne 0x1785
leaq 0x1(%r8), %r14
movq %r8, %rax
lock
cmpxchgq %r14, 0x98(%rdi)
jne 0x1756
jmp 0x1789
jge 0x174f
jmp 0x1796
addq %rbx, %r10
movq %r9, 0x8(%r10)
incq %rax
movq %rax, (%r10)
cmpq %r8, %r11
jne 0x17a6
incq %rcx
cmpq %rdx, %rcx
jne 0x174b
movq %rdx, %rcx
popq %rbx
popq %r14
jmp 0x17ad
xorl %ecx, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/stv0g[P]c11-queues/mpmc_queue.c
// Function: mpmc_queue_pull_many
int mpmc_queue_pull_many(struct mpmc_queue *q, void **ptr[], size_t cnt)
{
	int ret;
	size_t i;

	for (i = 0; i < cnt; i++) {
		ret = mpmc_queue_pull(q, ptr[i]);
		if (!ret)
			break;
	}
	
	return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x17e5
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebx, %ebx
movq (%r15,%rbx,8), %rsi
movq %r12, %rdi
callq 0x16ef
testl %eax, %eax
je 0x17e7
incq %rbx
cmpq %rbx, %r14
jne 0x17c8
movq %r14, %rbx
jmp 0x17e7
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ttoobne[P]bohttpd/src/core/log.c
// Function: log_log
void log_log(enum log_level level, const char* file, const char* function, const int line, const char* fmt, ...) {
    char log[MAX_LOG] = { '\0' };
    char date[18] = { '\0' };
    struct tm* tm;
    time_t now;
    va_list args;

    now = time(NULL);
    tm = localtime(&now);
    strftime(date, sizeof(date), "%y-%m-%d %H:%M:%S", tm);

    va_start(args, fmt);
    vsnprintf(log, sizeof(log), fmt, args);
    va_end(args);

    fprintf(stderr, "[%17s][%s(%d):%s]%s%s: \x1B[0m%s\n", 
                    date, file, line, function, level_colors[level], level_strings[level], log);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %r8, %r14
movl %ecx, -0x2c(%rbp)
movq %rdx, -0x40(%rbp)
movq %rsi, -0x38(%rbp)
movl %edi, %r13d
leaq -0x130(%rbp), %r15
movq %r9, 0x28(%r15)
testb %al, %al
je 0x2596
movaps %xmm0, -0x100(%rbp)
movaps %xmm1, -0xf0(%rbp)
movaps %xmm2, -0xe0(%rbp)
movaps %xmm3, -0xd0(%rbp)
movaps %xmm4, -0xc0(%rbp)
movaps %xmm5, -0xb0(%rbp)
movaps %xmm6, -0xa0(%rbp)
movaps %xmm7, -0x90(%rbp)
leaq -0x230(%rbp), %r12
movl $0x100, %edx            # imm = 0x100
movq %r12, %rdi
xorl %esi, %esi
callq 0x21b0
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %rbx
movaps %xmm0, (%rbx)
andw $0x0, 0x10(%rbx)
xorl %edi, %edi
callq 0x2290
leaq -0x48(%rbp), %rdi
movq %rax, (%rdi)
callq 0x2040
leaq 0x5741(%rip), %rdx      # 0x7d16
pushq $0x12
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
callq 0x2360
movabsq $0x3000000028, %rax     # imm = 0x3000000028
leaq -0x80(%rbp), %rcx
movq %rax, (%rcx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rcx)
movq %r15, 0x10(%rcx)
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
movq %r14, %rdx
callq 0x20c0
movq 0x89d9(%rip), %rax      # 0xaff0
movq (%rax), %rdi
movl %r13d, %eax
leaq 0x5770(%rip), %rcx      # 0x7d94
movslq (%rcx,%rax,4), %r10
addq %rcx, %r10
leaq 0x577a(%rip), %rcx      # 0x7dac
movslq (%rcx,%rax,4), %r11
addq %rcx, %r11
subq $0x8, %rsp
leaq 0x56e4(%rip), %rsi      # 0x7d28
movq %rbx, %rdx
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %r8d
movq -0x40(%rbp), %r9
xorl %eax, %eax
pushq %r12
pushq %r11
pushq %r10
callq 0x2240
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ttoobne[P]bohttpd/src/core/config.c
// Function: to_interger
static long to_interger(char* st, char* ed) {
    long result;
    char* p;

    result = 0;

    for (p = st; p <= ed; ++ p) {
        if (!isdigit(*p)) {
            return -1;
        }

        result = result * 10 + (*p - '0');

        if (result < 0) {
            return -1;
        }
    }

    return result;
}

// Assembly:
cmpq %rsi, %rdi
jbe 0x32da
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2490
movq (%rax), %rcx
xorl %edx, %edx
movsbq (%r14), %rsi
movq $-0x1, %rax
testb $0x8, 0x1(%rcx,%rsi,2)
je 0x331c
leaq (%rdx,%rdx,4), %rdx
leaq (%rsi,%rdx,2), %rdx
addq $-0x30, %rdx
js 0x331c
incq %r14
movq %rdx, %rax
cmpq %rbx, %r14
jbe 0x32f1
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ttoobne[P]bohttpd/src/core/epoll.c
// Function: epoll_create_fd
epoll_t* epoll_create_fd(int flags) {
    epoll_t* epoll = NULL;

    do {
        if ((epoll = (epoll_t*)malloc(sizeof(epoll_t))) == NULL) {
            log_error("epoll malloc failed.");
            break;
        }

        /* 创建 epoll 文件描述符 */
        if ((epoll->epollfd = epoll_create1(flags)) < 0) {
            log_error("epoll fd create failed.");
            break;
        }

        if ((epoll->events = (epoll_event*)malloc(sizeof(epoll_event) * MAX_EVENTS)) == NULL) {
            log_error("events malloc failed.");
            break;
        }

        return epoll;

    } while (0);

    if (epoll_free(epoll) != 0) {
        log_error("epoll free failed.");
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %r14d
movl $0x10, %edi
callq 0x22d0
movq %rax, %rbx
testq %rax, %rax
je 0x3382
movl %r14d, %edi
callq 0x2450
movl %eax, (%rbx)
testl %eax, %eax
js 0x33a3
movl $0x3000, %edi           # imm = 0x3000
callq 0x22d0
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x33d3
leaq 0x4124(%rip), %rsi      # 0x748c
leaq 0x412e(%rip), %rdx      # 0x749d
leaq 0x4164(%rip), %r8       # 0x74da
movl $0x4, %edi
movl $0x22, %ecx
jmp 0x33c2
leaq 0x4103(%rip), %rsi      # 0x748c
leaq 0x410d(%rip), %rdx      # 0x749d
leaq 0x4116(%rip), %r8       # 0x74ad
movl $0x4, %edi
movl $0x17, %ecx
jmp 0x33c2
leaq 0x40e2(%rip), %rsi      # 0x748c
leaq 0x40ec(%rip), %rdx      # 0x749d
leaq 0x410a(%rip), %r8       # 0x74c2
movl $0x4, %edi
movl $0x1d, %ecx
xorl %eax, %eax
callq 0x252a
movq %rbx, %rdi
callq 0x33db
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ttoobne[P]bohttpd/src/core/epoll.c
// Function: epoll_free
int epoll_free(epoll_t* epoll) {
    if (epoll != NULL) {
        free(epoll->events);
        epoll->events = NULL;
        free(epoll);
        epoll = NULL;
    }

    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x3408
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x2030
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
callq 0x2030
addq $0x8, %rsp
popq %rbx
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ttoobne[P]bohttpd/src/core/epoll.c
// Function: epoll_add_fd
int epoll_add_fd(epoll_t* epoll, int fd, epoll_event* event) {

    if (epoll == NULL) {
        log_error("epoll is null.");
        return -1;
    }

    /* 添加监听事件 */
    if (epoll_ctl(epoll->epollfd, EPOLL_CTL_ADD, fd, event) != 0) {
        log_error("epoll add fd failed.");
        return -1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x344a
movq %rdx, %rcx
movl %esi, %edx
movl (%rdi), %edi
movl $0x1, %esi
callq 0x21f0
testl %eax, %eax
je 0x3477
leaq 0x405c(%rip), %rsi      # 0x748c
leaq 0x40b9(%rip), %rdx      # 0x74f0
leaq 0x40ce(%rip), %r8       # 0x750c
movl $0x4, %edi
movl $0x3c, %ecx
jmp 0x3469
leaq 0x403b(%rip), %rsi      # 0x748c
leaq 0x4098(%rip), %rdx      # 0x74f0
leaq 0x409e(%rip), %r8       # 0x74fd
movl $0x4, %edi
movl $0x36, %ecx
xorl %eax, %eax
callq 0x252a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3479
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ttoobne[P]bohttpd/src/core/epoll.c
// Function: epoll_modify_fd
int epoll_modify_fd(epoll_t* epoll, int fd, epoll_event* event) {

    if (epoll == NULL) {
        log_error("epoll is null.");
        return -1;
    }

    /* 修改监听事件 */
    if (epoll_ctl(epoll->epollfd, EPOLL_CTL_MOD, fd, event) != 0) {
        log_error("epoll mod failed.");
        return -1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x34ba
movq %rdx, %rcx
movl %esi, %edx
movl (%rdi), %edi
movl $0x3, %esi
callq 0x21f0
testl %eax, %eax
je 0x34e7
leaq 0x3fec(%rip), %rsi      # 0x748c
leaq 0x407a(%rip), %rdx      # 0x7521
leaq 0x4083(%rip), %r8       # 0x7531
movl $0x4, %edi
movl $0x4f, %ecx
jmp 0x34d9
leaq 0x3fcb(%rip), %rsi      # 0x748c
leaq 0x4059(%rip), %rdx      # 0x7521
leaq 0x402e(%rip), %r8       # 0x74fd
movl $0x4, %edi
movl $0x49, %ecx
xorl %eax, %eax
callq 0x252a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x34e9
xorl %eax, %eax
popq %rbp
retq