LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/ctags/C.c
// Function: skip_key
int
skip_key(key)
	int	key;
{
	int	c,
		skip,
		retval;

	for (skip = retval = NO; GETC(!=, EOF);)
		switch(c) {
		case '\\':		/* a backslash escapes anything */
			skip = !skip;	/* we toggle in case it's "\\" */
			break;
		case ';':		/* special case for yacc; if one */
		case '|':		/* of these chars occurs, we may */
			retval = YES;	/* have moved out of the rule */
			break;		/* not used by C */
		case '\'':
		case '"':
			/* skip strings and character constants */
			skip_string(c);
			break;
		case '/':
			/* skip comments */
			if (GETC(==, '*')) {
				skip_comment();
				break;
			}
			(void)ungetc(c, inf);
			c = '/';
			goto norm;
		case '\n':
			SETLINE;
			/*FALLTHROUGH*/
		default:
		norm:
			if (c == key && !skip)
				return (retval);
			skip = NO;
		}
	return (retval);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %r12d, %r12d
leaq 0x36ae(%rip), %r15      # 0x5150
pushq $0x1
popq %r13
xorl %ebp, %ebp
movq (%r15), %rdi
callq 0x11d0
movl %eax, %r14d
cmpl $0x22, %eax
je 0x1ad8
cmpl $0x27, %r14d
je 0x1ad8
cmpl $0x2f, %r14d
jne 0x1ae2
movq (%r15), %rdi
callq 0x11d0
cmpl $0x2a, %eax
jne 0x1b28
callq 0x1a26
jmp 0x1aa8
movl %r14d, %edi
callq 0x19b4
jmp 0x1aa8
cmpl $-0x1, %r14d
je 0x1b44
cmpl $0xa, %r14d
je 0x1b0b
cmpl $0x3b, %r14d
je 0x1b06
cmpl $0x7c, %r14d
je 0x1b06
cmpl $0x5c, %r14d
jne 0x1b32
xorl $0x1, %r12d
jmp 0x1aa8
movl %r13d, %ebp
jmp 0x1aa8
leaq 0x3b5e(%rip), %rax      # 0x5670
incl (%rax)
movq (%r15), %rdi
callq 0x1110
leaq 0x435d(%rip), %rcx      # 0x5e80
movq %rax, (%rcx)
jmp 0x1b32
movq (%r15), %rsi
movl %eax, %edi
callq 0x1140
xorl %ebx, %r14d
orl %r12d, %r14d
movl $0x0, %r12d
jne 0x1aa8
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/ctags/ctags.c
// Function: init
void
init()
{
	int		i;
	unsigned char	*sp;

	for (i = 0; i < 256; i++) {
		_wht[i] = _etk[i] = _itk[i] = _btk[i] = NO;
		_gd[i] = YES;
	}
#define	CWHITE	(unsigned char *)" \f\t\n"
	for (sp = CWHITE; *sp; sp++)	/* white space chars */
		_wht[*sp] = YES;
#define	CTOKEN	(unsigned char *)" \t\n\"'#()[]{}=-+%*/&|^~!<>;,.:?"
	for (sp = CTOKEN; *sp; sp++)	/* token ending chars */
		_etk[*sp] = YES;
#define	CINTOK	(unsigned char *)"ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz0123456789"
	for (sp = CINTOK; *sp; sp++)	/* valid in-token chars */
		_itk[*sp] = YES;
#define	CBEGIN	(unsigned char *)"ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"
	for (sp = CBEGIN; *sp; sp++)	/* token starting chars */
		_btk[*sp] = YES;
#define	CNOTGD	(unsigned char *)",;"
	for (sp = CNOTGD; *sp; sp++)	/* invalid after-function chars */
		_gd[*sp] = NO;
}

// Assembly:
xorl %r8d, %r8d
leaq 0x3396(%rip), %rcx      # 0x5170
leaq 0x348f(%rip), %rdx      # 0x5270
leaq 0x3588(%rip), %rsi      # 0x5370
leaq 0x3681(%rip), %rdi      # 0x5470
leaq 0x377a(%rip), %rax      # 0x5570
xorl %r9d, %r9d
cmpq $0x100, %r9             # imm = 0x100
je 0x1e1c
movb %r8b, (%r9,%rcx)
movb %r8b, (%r9,%rdx)
movb %r8b, (%r9,%rsi)
movb %r8b, (%r9,%rdi)
movb $0x1, (%r9,%rax)
incq %r9
jmp 0x1df9
xorl %r8d, %r8d
leaq 0x12d4(%rip), %r9       # 0x30fa
cmpq $0x4, %r8
je 0x1e3b
movzbl (%r8,%r9), %r10d
movb $0x1, (%r10,%rdi)
incq %r8
jmp 0x1e26
xorl %edi, %edi
leaq 0x12bb(%rip), %r8       # 0x30ff
cmpq $0x1e, %rdi
je 0x1e59
movzbl (%rdi,%r8), %r9d
movb $0x1, (%r9,%rsi)
incq %rdi
jmp 0x1e44
xorl %esi, %esi
leaq 0x12bc(%rip), %rdi      # 0x311e
cmpq $0x3f, %rsi
je 0x1e77
movzbl (%rsi,%rdi), %r8d
movb $0x1, (%r8,%rdx)
incq %rsi
jmp 0x1e62
xorl %edx, %edx
leaq 0x12de(%rip), %rsi      # 0x315e
cmpq $0x35, %rdx
je 0x1e93
movzbl (%rdx,%rsi), %edi
movb $0x1, (%rdi,%rcx)
incq %rdx
jmp 0x1e80
xorl %ecx, %ecx
leaq 0x12f8(%rip), %rdx      # 0x3194
cmpq $0x2, %rcx
je 0x1eaf
movzbl (%rcx,%rdx), %esi
movb $0x0, (%rsi,%rax)
incq %rcx
jmp 0x1e9c
retq
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/ctags/ctags.c
// Function: find_entries
void
find_entries(file)
	char	*file;
{
	char	*cp;

	lineno = 0;				/* should be 1 ?? KB */
	if ((cp = strrchr(file, '.')) != NULL) {
		if (cp[1] == 'l' && !cp[2]) {
			int	c;

			for (;;) {
				if (GETC(==, EOF))
					return;
				if (!iswhite(c)) {
					rewind(inf);
					break;
				}
			}
#define	LISPCHR	";(["
/* lisp */		if (strchr(LISPCHR, c)) {
				l_entries();
				return;
			}
/* lex */		else {
				/*
				 * we search all 3 parts of a lex file
				 * for C references.  This may be wrong.
				 */
				toss_yysec();
				(void)strcpy(lbuf, "%%$");
				pfnote("yylex", lineno);
				rewind(inf);
			}
		}
/* yacc */	else if (cp[1] == 'y' && !cp[2]) {
			/*
			 * we search only the 3rd part of a yacc file
			 * for C references.  This may be wrong.
			 */
			toss_yysec();
			(void)strcpy(lbuf, "%%$");
			pfnote("yyparse", lineno);
			y_entries();
		}
/* fortran */	else if ((cp[1] != 'c' && cp[1] != 'h') && !cp[2]) {
			if (PF_funcs())
				return;
			rewind(inf);
		}
	}
/* C */	c_entries();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
andl $0x0, 0x37b5(%rip)      # 0x5670
pushq $0x2e
popq %rsi
callq 0x10c0
testq %rax, %rax
je 0x1fbd
movzbl 0x1(%rax), %ecx
cmpl $0x63, %ecx
je 0x1fbd
cmpl $0x68, %ecx
je 0x1fbd
cmpl $0x79, %ecx
je 0x1f4b
cmpl $0x6c, %ecx
jne 0x1f79
cmpb $0x0, 0x2(%rax)
jne 0x1fbd
leaq 0x356f(%rip), %r14      # 0x5470
movq 0x3248(%rip), %rdi      # 0x5150
callq 0x11d0
cmpl $-0x1, %eax
je 0x1f88
movl %eax, %ebx
movl %eax, %eax
cmpb $0x0, (%rax,%r14)
jne 0x1f01
movq 0x322c(%rip), %rdi      # 0x5150
callq 0x10b0
leaq 0x1267(%rip), %rdi      # 0x3197
pushq $0x4
popq %rdx
movl %ebx, %esi
callq 0x10d0
testq %rax, %rax
je 0x1f90
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2258
cmpb $0x0, 0x2(%rax)
jne 0x1fbd
callq 0x2a19
movl $0x242525, 0x3720(%rip) # imm = 0x242525
movl 0x370a(%rip), %esi      # 0x5670
leaq 0x1234(%rip), %rdi      # 0x31a1
callq 0x25d8
callq 0x2824
jmp 0x1fbd
cmpb $0x0, 0x2(%rax)
jne 0x1fbd
callq 0x1fcc
testl %eax, %eax
je 0x1fb1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2a19
movl $0x242525, 0x36e1(%rip) # imm = 0x242525
movl 0x36cb(%rip), %esi      # 0x5670
leaq 0x11ef(%rip), %rdi      # 0x319b
callq 0x25d8
movq 0x3198(%rip), %rdi      # 0x5150
callq 0x10b0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12ec
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/ctags/fortran.c
// Function: cicmp
int
cicmp(cp)
	char	*cp;
{
	int	len;
	char	*bp;

	for (len = 0, bp = lbp; *cp && (*cp &~ ' ') == (*bp++ &~ ' ');
	    ++cp, ++len)
		continue;
	if (!*cp) {
		lbp += len;
		return (YES);
	}
	return (NO);
}

// Assembly:
movq 0x3cc9(%rip), %rax      # 0x5e88
movb (%rdi), %cl
testb %cl, %cl
je 0x21d4
xorb (%rax), %cl
testb $-0x21, %cl
jne 0x21df
incq %rax
incq %rdi
jmp 0x21bf
movq %rax, 0x3cad(%rip)      # 0x5e88
pushq $0x1
popq %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/ctags/fortran.c
// Function: takeprec
static void
takeprec()
{
	for (; isspace(*lbp); ++lbp)
		continue;
	if (*lbp == '*') {
		for (++lbp; isspace(*lbp); ++lbp)
			continue;
		if (!isdigit(*lbp))
			--lbp;			/* force failure */
		else
			while (isdigit(*++lbp))
				continue;
	}
}

// Assembly:
pushq %rax
callq 0x11e0
movq 0x3c99(%rip), %rcx      # 0x5e88
incq %rcx
movq (%rax), %rsi
movsbq -0x1(%rcx), %rdx
testb $0x20, 0x1(%rsi,%rdx,2)
je 0x220a
movq %rcx, 0x3c80(%rip)      # 0x5e88
jmp 0x21ef
cmpb $0x2a, %dl
jne 0x2255
movq %rcx, 0x3c72(%rip)      # 0x5e88
movq (%rax), %rdx
movsbq (%rcx), %rsi
movzwl (%rdx,%rsi,2), %edx
incq %rcx
btl $0xd, %edx
jb 0x220f
btl $0xb, %edx
jb 0x223d
addq $-0x2, %rcx
movq %rcx, 0x3c4d(%rip)      # 0x5e88
jmp 0x2255
movq (%rax), %rdx
movq %rcx, 0x3c41(%rip)      # 0x5e88
movsbq (%rcx), %rsi
incq %rcx
testb $0x8, 0x1(%rdx,%rsi,2)
jne 0x223d
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/developer_cmds/ctags/print.c
// Function: ct_getline
void
ct_getline()
{
	long	saveftell;
	int	c;
	int	cnt;
	char	*cp;

	saveftell = ftell(inf);
	(void)fseek(inf, lineftell, SEEK_SET);
	if (xflag)
		for (cp = lbuf; GETC(!=, '\n'); *cp++ = c)
			continue;
	/*
	 * do all processing here, so we don't step through the
	 * line more than once; means you don't call this routine
	 * unless you're sure you've got a keeper.
	 */
	else for (cnt = 0, cp = lbuf; GETC(!=, EOF) && cnt < ENDLINE; ++cnt) {
		if (c == '\\') {		/* backslashes */
			if (cnt > ENDLINE - 2)
				break;
			*cp++ = '\\'; *cp++ = '\\';
			++cnt;
		}
		else if (c == (int)searchar) {	/* search character */
			if (cnt > ENDLINE - 2)
				break;
			*cp++ = '\\'; *cp++ = c;
			++cnt;
		}
		else if (c == '\n') {	/* end of keep */
			*cp++ = '$';		/* can find whole line */
			break;
		}
		else
			*cp++ = c;
	}
	*cp = EOS;
	(void)fseek(inf, saveftell, SEEK_SET);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x2d15(%rip), %r14      # 0x5150
movq (%r14), %rdi
callq 0x1110
movq %rax, %rbx
movq (%r14), %rdi
leaq 0x3a30(%rip), %rax      # 0x5e80
movq (%rax), %rsi
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x1160
leaq 0x2ce9(%rip), %rax      # 0x514c
cmpl $0x0, (%rax)
je 0x2484
leaq 0x3211(%rip), %r15      # 0x5680
movq (%r14), %rdi
callq 0x11d0
cmpl $0xa, %eax
je 0x24ea
movb %al, (%r15)
incq %r15
jmp 0x246f
leaq 0x31f5(%rip), %r15      # 0x5680
leaq 0x2c8a(%rip), %r12      # 0x511c
movq (%r14), %rdi
callq 0x11d0
cmpl $-0x1, %eax
je 0x24ea
cmpl $0x31, %ebp
jg 0x24ea
cmpl $0x5c, %eax
jne 0x24b6
cmpl $0x30, %ebp
jg 0x24ea
movw $0x5c5c, (%r15)         # imm = 0x5C5C
jmp 0x24cc
movsbl (%r12), %ecx
cmpl %ecx, %eax
jne 0x24d4
cmpl $0x30, %ebp
jg 0x24ea
movb $0x5c, (%r15)
movb %al, 0x1(%r15)
addq $0x2, %r15
incl %ebp
jmp 0x24df
cmpl $0xa, %eax
je 0x24e3
movb %al, (%r15)
incq %r15
incl %ebp
jmp 0x2492
movb $0x24, (%r15)
incq %r15
movb $0x0, (%r15)
movq (%r14), %rdi
movq %rbx, %rsi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1160
// File: /workspace/github_c_makefile_star2_O2/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 0x2c30(%rip), %r13      # 0x5148
leaq 0x2c2d(%rip), %rbp      # 0x514c
leaq 0xd32(%rip), %r15       # 0x3258
pushq $0x40
popq %r14
leaq 0xd1d(%rip), %r12       # 0x324e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x253e
callq 0x2503
cmpl $0x0, (%r13)
je 0x2568
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rcx
movl 0x28(%rbx), %eax
addl $0x3f, %eax
cltd
idivl %r14d
movq %r12, %rdi
movq %rcx, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0x1090
jmp 0x25bc
cmpl $0x0, (%rbp)
je 0x2589
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 0x25bc
leaq 0x2bd8(%rip), %rax      # 0x5168
movq (%rax), %rdi
movq 0x10(%rbx), %rdx
movq 0x18(%rbx), %rcx
leaq 0x2b7a(%rip), %rax      # 0x511c
movsbl (%rax), %r8d
movq 0x20(%rbx), %r9
movl %r8d, (%rsp)
leaq 0xcb6(%rip), %rsi       # 0x326b
xorl %eax, %eax
callq 0x1100
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2531
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0x281f
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2812
callq 0x27fb
movq %rbx, %rdi
callq 0x1030
movq (%rbx), %rbx
jmp 0x27ff
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x2728(%rip), %rbx      # 0x5150
movq (%rbx), %rdi
callq 0x1110
leaq 0x3449(%rip), %r14      # 0x5e80
movq %rax, (%r14)
xorl %r12d, %r12d
leaq 0x2c2c(%rip), %r15      # 0x5670
pushq $0x1
popq %rbp
movq (%rbx), %rdi
callq 0x11d0
cmpl $0xa, %eax
je 0x2a77
cmpl $0x25, %eax
je 0x2a66
movl $0x0, %r12d
cmpl $-0x1, %eax
jne 0x2a47
jmp 0x2a8e
leal 0x1(%r12), %eax
testl %r12d, %r12d
cmovel %r12d, %eax
movl %eax, %r12d
jmp 0x2a47
incl (%r15)
movq (%rbx), %rdi
callq 0x1110
movq %rax, (%r14)
cmpl $0x3, %r12d
movl %ebp, %r12d
jne 0x2a47
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x32f2(%rip), %rbx      # 0x44c0
leaq 0xe61(%rip), %r14       # 0x2036
leaq 0x3354(%rip), %r15      # 0x4530
leaq 0xe7f(%rip), %r12       # 0x2062
leaq 0x2ee6(%rip), %r13      # 0x40d0
leaq 0xe9d(%rip), %rbp       # 0x208e
callq 0x12fd
cmpl $-0x1, %eax
je 0x12ec
cmpl $0xa, 0x2ec6(%rip)      # 0x40cc
je 0x12e0
movb $0x0, 0x2ebd(%rip)      # 0x40d0
movq %rbx, %rdi
callq 0x13d5
testl %eax, %eax
je 0x1268
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1030
callq 0x1415
movl 0x2e97(%rip), %esi      # 0x40cc
testl %esi, %esi
je 0x129d
cmpl $0xa, %esi
jne 0x12b3
cmpl $0x0, 0x2e83(%rip)      # 0x40c8
jne 0x12d9
leaq 0xe68(%rip), %rdi       # 0x20ba
leaq 0x3347(%rip), %rsi      # 0x45a0
movq %r13, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1050
jmp 0x12d9
movl $0x1, 0x2e56(%rip)      # 0x40c8
movq 0x2e47(%rip), %rdx      # 0x40c0
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
callq 0x12fd
movl 0x2e3b(%rip), %eax      # 0x40cc
cmpl $-0x1, %eax
je 0x12e0
cmpl $0xa, %eax
jne 0x1286
jmp 0x12e0
movq 0x2e1c(%rip), %rdx      # 0x40c0
movq %r12, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
jmp 0x12c4
movq 0x2e06(%rip), %rdx      # 0x40c0
movq %rbp, %rdi
xorl %eax, %eax
callq 0x1050
callq 0x12fd
movl 0x2dfd(%rip), %eax      # 0x40cc
cmpl $-0x1, %eax
je 0x12d9
cmpl $0xa, %eax
jne 0x12c4
andl $0x0, 0x2de8(%rip)      # 0x40c8
incq 0x2dd9(%rip)            # 0x40c0
jmp 0x11f1
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/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
leaq 0x2c8c(%rip), %r14      # 0x4070
xorl %ecx, %ecx
movq %rcx, %r15
cmpq $0x8, %rcx
je 0x1406
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1060
leaq 0x1(%r15), %rcx
addq $0x8, %r14
testl %eax, %eax
jne 0x13e6
xorl %eax, %eax
cmpq $0x8, %r15
setb %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rbp
callq 0x12fd
decl %ebp
cmpl $0x2a, %eax
je 0x141c
callq 0x15a5
leaq 0x2c9c(%rip), %rbx      # 0x40d0
movabsq $0x7265746e696f7020, %r14 # imm = 0x7265746E696F7020
testl %ebp, %ebp
je 0x145a
movq %rbx, %rdi
callq 0x1040
movq %r14, (%rax,%rbx)
movl $0x6f7420, 0x8(%rax,%rbx) # imm = 0x6F7420
incl %ebp
jmp 0x143e
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2b16(%rip), %eax      # 0x40cc
testl %eax, %eax
je 0x15e7
cmpl $0x28, %eax
jne 0x15fc
callq 0x1415
cmpl $0x29, 0x2b01(%rip)     # 0x40cc
je 0x161b
movl $0x1, 0x2af1(%rip)      # 0x40c8
movq 0x2ae2(%rip), %rsi      # 0x40c0
leaq 0xafd(%rip), %rdi       # 0x20e2
jmp 0x1614
leaq 0x2fb2(%rip), %rdi      # 0x45a0
leaq 0x2ecb(%rip), %rsi      # 0x44c0
callq 0x1030
jmp 0x161b
movl $0x1, 0x2ac2(%rip)      # 0x40c8
movq 0x2ab3(%rip), %rsi      # 0x40c0
leaq 0xaf6(%rip), %rdi       # 0x210a
xorl %eax, %eax
callq 0x1050
leaq 0x2aae(%rip), %rbx      # 0x40d0
movabsq $0x5b796172726120, %r12 # imm = 0x5B796172726120
leaq 0x2e8d(%rip), %r14      # 0x44c0
movabsq $0x74657220646e6120, %r13 # imm = 0x74657220646E6120
movabsq $0x676e696e727574, %rbp # imm = 0x676E696E727574
leaq 0xa94(%rip), %r15       # 0x20e2
callq 0x12fd
movl %eax, 0x2a73(%rip)      # 0x40cc
cmpl $0x1, %eax
je 0x1700
cmpl $0x2, %eax
je 0x16d0
cmpl $0x28, %eax
jne 0x1720
movq %rbx, %rdi
callq 0x1040
movups 0xabe(%rip), %xmm0      # 0x213d
movups %xmm0, (%rax,%rbx)
movl $0x676e69, 0x10(%rax,%rbx) # imm = 0x676E69
callq 0x172f
movq %rbx, %rdi
callq 0x1040
movq %r13, (%rax,%rbx)
movq %rbp, 0x7(%rax,%rbx)
cmpl $0x29, 0x2a24(%rip)     # 0x40cc
je 0x164e
movl $0x1, 0x2a14(%rip)      # 0x40c8
movq 0x2a05(%rip), %rsi      # 0x40c0
movq %r15, %rdi
xorl %eax, %eax
callq 0x1050
cmpl $0xa, 0x2a00(%rip)      # 0x40cc
jne 0x164e
jmp 0x1720
movq %rbx, %rdi
callq 0x1040
movq %r12, (%rax,%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1090
movq %rbx, %rdi
callq 0x1040
movl $0x666f205d, (%rax,%rbx) # imm = 0x666F205D
movb $0x0, 0x4(%rax,%rbx)
jmp 0x164e
movq %rbx, %rdi
callq 0x1040
movups 0xa51(%rip), %xmm0      # 0x2160
movups %xmm0, (%rax,%rbx)
movl $0x676e69, 0x10(%rax,%rbx) # imm = 0x676E69
jmp 0x164e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x16cad(%rip), %rdi     # 0x19004
xorl %eax, %eax
callq 0x2040
leaq 0x16efe(%rip), %rdi     # 0x19263
callq 0x2210
leaq 0x16ef9(%rip), %rdi     # 0x1926a
callq 0x2210
leaq 0x16f19(%rip), %rdi     # 0x19296
callq 0x2210
leaq 0x16f37(%rip), %rdi     # 0x192c0
callq 0x2210
leaq 0x16f4a(%rip), %rdi     # 0x192df
callq 0x2210
leaq 0x16f70(%rip), %rdi     # 0x19311
callq 0x2210
leaq 0x16f86(%rip), %rdi     # 0x19333
callq 0x2210
leaq 0x16fa7(%rip), %rdi     # 0x19360
callq 0x2210
leaq 0x16fc1(%rip), %rdi     # 0x19386
callq 0x2210
leaq 0x16feb(%rip), %rdi     # 0x193bc
popq %rax
jmp 0x2210
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/demos/demo_get.c
// Function: parse_arguments
int
parse_arguments(int argc, char **argv,
                char **server_address, char **server_port,
                char **client_certificate, char **client_key, char **ca_certificate,
                char **username, char **password,
                char **id,
                int *print_usage)
{
    if(argc <= 1)
    {
        print_help(argv[0]);
        return(-1);
    }
    
    for(int i = 1; i < argc; i++)
    {
        if(strncmp(argv[i], "-a", 2) == 0)
        {
            *server_address = argv[++i];
        }
        else if(strncmp(argv[i], "-c", 2) == 0)
        {
            *client_certificate = argv[++i];
        }
        else if(strncmp(argv[i], "-h", 2) == 0)
        {
            *print_usage = 1;
        }
        else if(strncmp(argv[i], "-i", 2) == 0)
        {
            *id = argv[++i];
        }
        else if(strncmp(argv[i], "-k", 2) == 0)
        {
            *client_key = argv[++i];
        }
        else if(strncmp(argv[i], "-p", 2) == 0)
        {
            *server_port = argv[++i];
        }
        else if(strncmp(argv[i], "-r", 2) == 0)
        {
            *ca_certificate = argv[++i];
        }
        else if(strncmp(argv[i], "-s", 2) == 0)
        {
            *password = argv[++i];
        }
        else if(strncmp(argv[i], "-u", 2) == 0)
        {
            *username = argv[++i];
        }
        else
        {
            printf("Invalid option: '%s'\n", argv[i]);
            print_help(argv[0]);
            return(-1);
        }
    }
    
    return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
cmpl $0x2, %edi
jge 0x23f7
movq (%r14), %rdi
callq 0x234c
pushq $-0x1
popq %rax
jmp 0x24f2
movl %edi, %ebx
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %r10
movq 0x38(%rsp), %r11
movq 0x30(%rsp), %r15
pushq $0x1
popq %rbp
cmpl %ebx, %ebp
jge 0x24e9
movslq %ebp, %r12
movq (%r14,%r12,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x24d3
cmpb $0x61, 0x1(%rsi)
jne 0x2442
incl %ebp
movq 0x8(%r14,%r12,8), %rsi
movq %rsi, (%rdx)
jmp 0x24cc
cmpb $0x63, 0x1(%rsi)
jne 0x2454
incl %ebp
movq 0x8(%r14,%r12,8), %rsi
movq %rsi, (%r8)
jmp 0x24cc
cmpb $0x68, 0x1(%rsi)
jne 0x2462
movl $0x1, (%rax)
jmp 0x24cc
cmpb $0x69, 0x1(%rsi)
jne 0x2474
incl %ebp
movq 0x8(%r14,%r12,8), %rsi
movq %rsi, (%rdi)
jmp 0x24cc
cmpb $0x6b, 0x1(%rsi)
jne 0x2486
incl %ebp
movq 0x8(%r14,%r12,8), %rsi
movq %rsi, (%r9)
jmp 0x24cc
cmpb $0x70, 0x1(%rsi)
jne 0x2498
incl %ebp
movq 0x8(%r14,%r12,8), %rsi
movq %rsi, (%rcx)
jmp 0x24cc
cmpb $0x72, 0x1(%rsi)
jne 0x24aa
incl %ebp
movq 0x8(%r14,%r12,8), %rsi
movq %rsi, (%r15)
jmp 0x24cc
cmpb $0x73, 0x1(%rsi)
jne 0x24bc
incl %ebp
movq 0x8(%r14,%r12,8), %rsi
movq %rsi, (%r10)
jmp 0x24cc
cmpb $0x75, 0x1(%rsi)
jne 0x24d3
incl %ebp
movq 0x8(%r14,%r12,8), %rsi
movq %rsi, (%r11)
incl %ebp
jmp 0x2415
leaq 0x16b4e(%rip), %rdi     # 0x19028
xorl %eax, %eax
callq 0x2040
movq (%r14), %rdi
callq 0x234c
xorl %eax, %eax
cmpl %ebx, %ebp
setl %al
negl %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x48(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x40(%rsp), %rcx
andq $0x0, (%rcx)
leaq 0x38(%rsp), %r8
andq $0x0, (%r8)
leaq 0x30(%rsp), %r9
andq $0x0, (%r9)
leaq 0x28(%rsp), %rax
andq $0x0, (%rax)
leaq 0x20(%rsp), %r10
andq $0x0, (%r10)
leaq 0x18(%rsp), %r11
andq $0x0, (%r11)
leaq 0x10(%rsp), %r14
andq $0x0, (%r14)
leaq 0xc(%rsp), %r15
andl $0x0, (%r15)
subq $0x8, %rsp
pushq %r15
pushq %r14
pushq %r11
pushq %r10
pushq %rax
callq 0x23d7
addq $0x30, %rsp
testl %eax, %eax
je 0x2a67
pushq $-0x1
popq %rax
jmp 0x2a78
cmpl $0x0, 0xc(%rsp)
je 0x2a82
movq (%rbx), %rdi
callq 0x234c
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 0x2582
addq $0x60, %rsp
jmp 0x2a7c
nop
// File: /workspace/github_c_makefile_star2_O2/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
movl (%rbx), %ecx
pushq $0x3c
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
movl %edx, %r8d
leal 0x3b(%rcx), %edx
cmpl $0x76, %edx
ja 0x11a4
leaq 0xe81(%rip), %rdi       # 0x2012
leaq 0xe86(%rip), %rdx       # 0x201e
movq %rdx, %rsi
xorl %eax, %eax
callq 0x1030
jmp 0x11f6
cmpl $0xe0f, %ecx            # imm = 0xE0F
jg 0x11c8
leaq 0xe6e(%rip), %rdi       # 0x2021
leaq 0xe64(%rip), %rsi       # 0x201e
movl %eax, %edx
movl %r8d, %ecx
xorl %eax, %eax
callq 0x1030
jmp 0x11f6
movl $0xe10, %esi            # imm = 0xE10
movl %ecx, %eax
xorl %edx, %edx
divl %esi
movl %eax, %esi
movl %edx, %eax
movw $0x3c, %cx
xorl %edx, %edx
divw %cx
movzwl %ax, %eax
movzwl %dx, %ecx
leaq 0xe42(%rip), %rdi       # 0x202f
movl %eax, %edx
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x28fa(%rip), %esi      # 0x411c
leal 0x1(%rsi), %ecx
movl %ecx, 0x28f1(%rip)      # 0x411c
cmpl $0x0, 0x28e6(%rip)      # 0x4118
jne 0x1881
movl 0x2896(%rip), %edi      # 0x40d0
shll $0x2, %ecx
shll $0x2, %esi
movl $0x2, %r8d
leaq 0x2843(%rip), %r9       # 0x4090
movl %ecx, %eax
subl %esi, %eax
jle 0x1881
cltd
idivl %r8d
addl %esi, %eax
movslq %eax, %rdx
movl (%r9,%rdx,4), %edx
cmpl %edi, %edx
je 0x1877
leal -0x1(%rax), %r10d
incl %eax
cmpl %edi, %edx
cmovgl %esi, %eax
cmovgl %r10d, %ecx
movl %eax, %esi
jmp 0x184d
movl $0x1, 0x2897(%rip)      # 0x4118
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 -0x85(%rip), %rbx       # 0x1818
cmpq $0x20, %r14
je 0x18bb
leaq (%r14,%rbp), %rdi
addq $-0x30, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x14aa
addq $0x8, %r14
jmp 0x189d
xorl %ebx, %ebx
cmpq $0x4, %rbx
je 0x18d4
movq -0x30(%rbp,%rbx,8), %rdi
xorl %esi, %esi
callq 0x15c3
incq %rbx
jmp 0x18bd
movl 0x283e(%rip), %eax      # 0x4118
cmpl 0x27f4(%rip), %eax      # 0x40d4
leaq 0x74a(%rip), %rax       # 0x2031
leaq 0x780(%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_O2/sgsfak[P]c-ocgeo/src/ocgeo.h
// Function: ocgeo_decimal_coords_to_degrees
static inline
ocgeo_dms_t ocgeo_decimal_coords_to_degrees(double decimal)
{
	bool neg = decimal < 0;
	if (neg) 
		decimal = -decimal;
	int degrees =  (int) decimal;
	ocgeo_dms_t d;
	d.degrees = neg ? -degrees : degrees;
	d.minutes = (int) ((decimal - degrees) * 60);
	d.seconds = 3600 * (decimal - degrees) - 60 * d.minutes;
	return d;
}

// Assembly:
movapd 0x464a(%rip), %xmm1     # 0x6060
xorpd %xmm0, %xmm1
movapd %xmm1, %xmm2
maxsd %xmm0, %xmm2
cvttsd2si %xmm2, %ecx
movl %ecx, %eax
negl %eax
ucomisd %xmm0, %xmm1
cmovbel %ecx, %eax
cvttpd2dq %xmm2, %xmm0
cvtdq2pd %xmm0, %xmm0
subsd %xmm0, %xmm2
movsd 0x460b(%rip), %xmm0     # 0x6050
mulsd %xmm2, %xmm0
cvttsd2si %xmm0, %ecx
imull $0x3c, %ecx, %edx
cvtsi2sd %edx, %xmm0
mulsd 0x45fc(%rip), %xmm2     # 0x6058
subsd %xmm0, %xmm2
cvtsd2ss %xmm2, %xmm0
shlq $0x20, %rcx
orq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x49e8(%rip), %xmm0     # 0x64c0
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2a06
leaq 0x3f7b(%rip), %rsi      # 0x65ed
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movb $0x2, %al
callq 0x2d75
movq %rax, %r12
xorl %edi, %edi
movq %rax, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x1af6
movl %eax, %ebx
movq %r12, %rdi
callq 0x2a3e
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x274b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq %rdi, %r14
movslq 0x24(%rbx), %rax
imulq $0xe8, %rax, %rax
addq %rdi, %rax
cmpq %rax, %r14
je 0x271a
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
jmp 0x26cd
andl $0x0, 0x24(%rbx)
callq 0x11f8
andq $0x0, 0x28(%rbx)
movq 0x30(%rbx), %rdi
callq 0x387e
andq $0x0, 0x30(%rbx)
movq 0x10(%rbx), %rdi
callq 0x2a3e
andq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2795
testq %rax, %rax
je 0x2773
movq %rax, %r14
movq %rax, %rdi
callq 0x5330
testl %eax, %eax
je 0x2780
movb $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x37ce
testl %eax, %eax
je 0x2773
movb $0x1, (%rbx)
movq 0x20(%r14), %rax
jmp 0x2778
// File: /workspace/github_c_makefile_star2_O2/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 0x2880
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
movq %rsi, %rdi
callq 0x1090
leaq 0x408d(%rip), %rdx      # 0x6851
pushq $0x1
popq %rcx
movq %r14, %rdi
movl %eax, %esi
movq %r15, %r8
callq 0x2fbb
testq %rax, %rax
je 0x2880
movq %rax, %r14
xorl %r15d, %r15d
leaq 0x3cf6(%rip), %r12      # 0x64e0
movslq 0x4(%rsp), %rsi
cmpq %rsi, %r15
jge 0x2884
testq %rbx, %rbx
je 0x2884
movq (%r14,%r15,8), %rsi
movl -0x8(%rsi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x285d
movzbl (%rsi,%rdx), %edi
addl $-0x30, %edi
cmpl $0x9, %edi
ja 0x286d
imull $0xb, %eax, %eax
movslq (%r12,%rdi,4), %rdi
addq %r12, %rdi
jmpq *%rdi
incl %eax
jmp 0x2858
addl $0x4, %eax
jmp 0x2858
addl $0x9, %eax
jmp 0x2858
addl $0x2, %eax
jmp 0x2858
addl $0x3, %eax
jmp 0x2858
addl $0x7, %eax
jmp 0x2858
addl $0x5, %eax
jmp 0x2858
addl $0x6, %eax
jmp 0x2858
addl $0x8, %eax
incq %rdx
jmp 0x2811
testl %eax, %eax
js 0x286d
movq %rbx, %rdi
movl %eax, %esi
callq 0x459a
jmp 0x2875
movq %rbx, %rdi
callq 0x4667
movq %rax, %rbx
incq %r15
jmp 0x27ea
xorl %ebx, %ebx
jmp 0x288c
movq %r14, %rdi
callq 0x3179
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2795
testq %rax, %rax
je 0x28c2
movq %rax, %r14
movq %rax, %rdi
callq 0x5330
testl %eax, %eax
je 0x28cf
movb $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x533f
testl %eax, %eax
je 0x28c2
movb $0x1, (%rbx)
movl 0x28(%r14), %eax
jmp 0x28c7
// File: /workspace/github_c_makefile_star2_O2/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 0x2795
testq %rax, %rax
je 0x290b
movq %rax, %r14
movq %rax, %rdi
callq 0x5330
testl %eax, %eax
je 0x2919
movb $0x0, (%rbx)
xorps %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x533f
testl %eax, %eax
je 0x290b
movb $0x1, (%rbx)
movsd 0x30(%r14), %xmm0
jmp 0x2911
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
callq 0x1090
leal -0x1(%rax), %edi
callq 0x1080
callq 0x10f0
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %edx, %ebp
cmpl $0x0, 0x2e71(%rip)      # 0x40a0
jne 0x1238
callq 0x1070
jmp 0x1228
movslq %ebp, %rax
subq $0x1, %rax
jb 0x1245
pause
jmp 0x123b
pushq $0x1
popq %rbp
xorl %r14d, %r14d
leaq 0x2e5e(%rip), %r15      # 0x40b0
xorl %eax, %eax
cmpq $0x1312d00, %r14        # imm = 0x1312D00
je 0x1290
addl %ebp, %eax
movl %eax, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1649
testl %eax, %eax
je 0x127f
movl %ebp, %eax
movl (%r15), %ebp
incq %r14
addq $0x4, %r15
jmp 0x1254
leaq 0xd7e(%rip), %rdi       # 0x2004
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
xorl %eax, %eax
cmpq $0x1312d00, %r14        # imm = 0x1312D00
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
callq 0x1090
leal -0x1(%rax), %edi
callq 0x1080
callq 0x10f0
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %edx, %ebp
cmpl $0x0, 0x2dc7(%rip)      # 0x40a0
jne 0x12e2
callq 0x1070
jmp 0x12d2
movslq %ebp, %rax
subq $0x1, %rax
jb 0x12ef
pause
jmp 0x12e5
pushq $0x1
popq %r12
xorl %r15d, %r15d
movq %rsp, %r14
xorl %r13d, %r13d
cmpq $0x1312d00, %r15        # imm = 0x1312D00
je 0x133a
addq %r12, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x168c
testl %eax, %eax
je 0x1308
movq (%rsp), %rax
cmpl %r13d, (%rax)
jne 0x132e
movslq %r13d, %rax
incq %r15
movq %r12, %r13
movq %rax, %r12
jmp 0x12fc
leaq 0xd5f(%rip), %rdi       # 0x2094
callq 0x1040
xorl %eax, %eax
cmpq $0x1312d00, %r15        # imm = 0x1312D00
sbbl %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/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, 0x2d3b(%rip)      # 0x40a0
callq 0x1200
movl %eax, %ebx
testl %eax, %eax
je 0x137c
leaq 0xd2b(%rip), %rdi       # 0x20a2
callq 0x1040
movq %r14, %rdi
callq 0x12a6
movl %eax, %ebp
testl %eax, %eax
je 0x1396
leaq 0xd22(%rip), %rdi       # 0x20b3
callq 0x1040
orl %ebx, %ebp
leaq 0xd24(%rip), %rax       # 0x20c3
leaq 0xd39(%rip), %rdi       # 0x20df
cmoveq %rax, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x2cd0(%rip)      # 0x40a0
leaq -0x131(%rip), %rsi      # 0x12a6
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x14d2
leaq -0x1ee(%rip), %rsi      # 0x1200
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x14d2
pushq $0x1
popq %rdi
callq 0x10e0
rdtsc
shlq $0x20, %rdx
orq %rdx, %rax
movq %rax, %r14
movl $0x1, 0x2c84(%rip)      # 0x40a0
movq (%r15), %rdi
leaq 0xc(%rsp), %r15
movq %r15, %rsi
callq 0x14df
movq (%r12), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x14df
rdtsc
shlq $0x20, %rdx
orq %rdx, %rax
movq %rax, %r13
movl (%r15), %eax
orl (%r12), %eax
leaq 0xcbb(%rip), %rax       # 0x2112
leaq 0xc9b(%rip), %rdi       # 0x20f9
cmovneq %rax, %rdi
callq 0x1040
subq %r14, %r13
movl $0x1312d00, %ecx        # imm = 0x1312D00
movq %r13, %rax
xorl %edx, %edx
divq %rcx
leaq 0xba6(%rip), %rdi       # 0x2024
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x1637
testq %rax, %rax
je 0x14a6
leaq 0xba1(%rip), %rdi       # 0x203d
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x161b
testl %eax, %eax
je 0x14c2
leaq 0xbbe(%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_O2/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:
pushq $-0x1
popq %rax
cmpq $0x2, %rsi
jb 0x161a
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 0x1613
leaq -0x1(%r14), %rax
movq %rdx, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movq %r14, %rsi
shlq $0x4, %rsi
movq %rdx, %rdi
callq 0x1754
movq %rax, 0x50(%rbx)
testq %rax, %rax
je 0x1610
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x15f6
movq 0x50(%rbx), %rdx
movq %rcx, (%rdx,%rax)
incq %rcx
addq $0x10, %rax
jmp 0x15e0
movq $0x0, 0x98(%rbx)
movq $0x0, 0xe0(%rbx)
xorl %eax, %eax
jmp 0x1613
pushq $-0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x1707
movq (%r14,%r12,8), %rsi
movq %r15, %rdi
callq 0x1649
testl %eax, %eax
je 0x1704
incq %r12
jmp 0x16ea
movq %r12, %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq