LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Vatoth[P]CPE_2016_Lemin/my_printf/my_base.c
// Function: my_base_pointer
void	my_base_pointer(va_list ap, char flag)
{
  if ('x' == flag)
    my_base(va_arg(ap, int), "0123456789abcdef");
  else if ('o' == flag)
    my_base(va_arg(ap, int), "01234567");
  else
    my_base(va_arg(ap, int), "01");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %ecx
movl $0x78, %eax
cmpl %ecx, %eax
jne 0x3c78
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x28, %eax
ja 0x3c4a
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x20(%rbp)
jmp 0x3c61
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
leaq 0x42c(%rip), %rsi       # 0x409a
callq 0x3b70
jmp 0x3d31
movsbl -0x9(%rbp), %ecx
movl $0x6f, %eax
cmpl %ecx, %eax
jne 0x3cdb
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x28, %eax
ja 0x3cb0
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x38(%rbp)
jmp 0x3cc7
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %edi
leaq 0x3ac(%rip), %rsi       # 0x4080
callq 0x3b70
jmp 0x3d2f
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x28, %eax
ja 0x3d06
movq -0x48(%rbp), %rcx
movl -0x3c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x50(%rbp)
jmp 0x3d1d
movq -0x48(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movl (%rax), %edi
leaq 0x381(%rip), %rsi       # 0x40ab
callq 0x3b70
jmp 0x3d31
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Vatoth[P]CPE_2016_Lemin/my_printf/my_put_pointers.c
// Function: my_base_pointers
static long	my_base_pointers(long nb, const char *base)
{
  long		result;
  long		modulo;

  if (nb < 0)
    {
      my_putchar('-');
      nb = -nb;
    }
  result = nb / my_strlen(base);
  modulo = nb % my_strlen(base);
  if (result > 0)
    my_base_pointers(result, base);
  my_putchar(base[modulo]);
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jge 0x3deb
movl $0x2d, %edi
callq 0x33d0
xorl %eax, %eax
subq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3470
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3470
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
cqto
idivq %rcx
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x3e45
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3dc0
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x33d0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Vatoth[P]CPE_2016_Lemin/my_printf/my_put_unsigned.c
// Function: my_put_unsigned
int     my_put_unsigned(unsigned int nb)
{
  int   modulo;

  if (nb > 0)
    {
      if (nb > 9)
	{
	  modulo = nb % 10;
	  nb = (nb - modulo) / 10;
	  my_put_nbr(nb);
	  my_putchar(48 + modulo);
	}
      else
	{
	  my_putchar(nb + 48);
	}
    }
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jbe 0x3ec0
cmpl $0x9, -0x4(%rbp)
jbe 0x3eb0
movl -0x4(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x8(%rbp)
movl -0x4(%rbp), %eax
subl -0x8(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x3700
movl -0x8(%rbp), %eax
addl $0x30, %eax
movsbl %al, %edi
callq 0x33d0
jmp 0x3ebe
movl -0x4(%rbp), %eax
addl $0x30, %eax
movsbl %al, %edi
callq 0x33d0
jmp 0x3ec0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/darwin-on-arm[P]darwin-sdk/developer_cmds/ctags/C.c
// Function: skip_string
void
skip_string(key)
	int	key;
{
	int	c,
		skip;

	for (skip = NO; GETC(!=, EOF); )
		switch (c) {
		case '\\':		/* a backslash escapes anything */
			skip = !skip;	/* we toggle in case it's "\\" */
			break;
		case '\n':
			SETLINE;
			/*FALLTHROUGH*/
		default:
			if (c == key && !skip)
				return;
			skip = NO;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x4a27(%rip), %rax      # 0x6140
movq (%rax), %rdi
callq 0x11b0
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0x17a0
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0xa, %eax
je 0x1753
jmp 0x1736
movl -0x10(%rbp), %eax
subl $0x5c, %eax
jne 0x1784
jmp 0x1740
cmpl $0x0, -0xc(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
jmp 0x179b
leaq 0x4f06(%rip), %rax      # 0x6660
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x4efa(%rip), %rax      # 0x6660
movl %ecx, (%rax)
leaq 0x49d1(%rip), %rax      # 0x6140
movq (%rax), %rdi
callq 0x1110
movq %rax, %rcx
leaq 0x56ef(%rip), %rax      # 0x6e70
movq %rcx, (%rax)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x1794
cmpl $0x0, -0xc(%rbp)
jne 0x1794
jmp 0x17a0
movl $0x0, -0xc(%rbp)
jmp 0x1712
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/darwin-on-arm[P]darwin-sdk/developer_cmds/ctags/C.c
// Function: skip_comment
void
skip_comment()
{
	int	c;			/* character read */
	int	star;			/* '*' flag */

	for (star = 0; GETC(!=, EOF);)
		switch(c) {
		/* comments don't nest, nor can they be escaped. */
		case '*':
			star = YES;
			break;
		case '/':
			if (star)
				return;
			break;
		case '\n':
			SETLINE;
			/*FALLTHROUGH*/
		default:
			star = NO;
			break;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
leaq 0x497a(%rip), %rax      # 0x6140
movq (%rax), %rdi
callq 0x11b0
movl %eax, -0x4(%rbp)
cmpl $-0x1, %eax
je 0x1847
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0xa, %eax
je 0x180a
jmp 0x17e3
movl -0xc(%rbp), %eax
subl $0x2a, %eax
je 0x17f7
jmp 0x17ed
movl -0xc(%rbp), %eax
subl $0x2f, %eax
je 0x1800
jmp 0x183b
movl $0x1, -0x8(%rbp)
jmp 0x1842
cmpl $0x0, -0x8(%rbp)
je 0x1808
jmp 0x1847
jmp 0x1842
leaq 0x4e4f(%rip), %rax      # 0x6660
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x4e43(%rip), %rax      # 0x6660
movl %ecx, (%rax)
leaq 0x491a(%rip), %rax      # 0x6140
movq (%rax), %rdi
callq 0x1110
movq %rax, %rcx
leaq 0x5638(%rip), %rax      # 0x6e70
movq %rcx, (%rax)
movl $0x0, -0x8(%rbp)
jmp 0x17bf
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
leaq 0x4220(%rip), %rax      # 0x6140
movq (%rax), %rdi
callq 0x11b0
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
je 0x2041
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0xa, %eax
je 0x1fec
jmp 0x1f45
movl -0x18(%rbp), %eax
subl $0x22, %eax
je 0x1fa6
jmp 0x1f4f
movl -0x18(%rbp), %eax
subl $0x27, %eax
je 0x1fa6
jmp 0x1f59
movl -0x18(%rbp), %eax
subl $0x2f, %eax
je 0x1fb3
jmp 0x1f63
movl -0x18(%rbp), %eax
subl $0x3b, %eax
je 0x1f9a
jmp 0x1f6d
movl -0x18(%rbp), %eax
subl $0x5c, %eax
je 0x1f84
jmp 0x1f77
movl -0x18(%rbp), %eax
subl $0x7c, %eax
je 0x1f9a
jmp 0x201d
cmpl $0x0, -0x10(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
jmp 0x203c
movl $0x1, -0x14(%rbp)
jmp 0x203c
movl -0xc(%rbp), %edi
callq 0x1700
jmp 0x203c
leaq 0x4186(%rip), %rax      # 0x6140
movq (%rax), %rdi
callq 0x11b0
movl %eax, -0xc(%rbp)
cmpl $0x2a, %eax
jne 0x1fd1
callq 0x17b0
jmp 0x203c
movl -0xc(%rbp), %edi
leaq 0x4165(%rip), %rax      # 0x6140
movq (%rax), %rsi
callq 0x1140
movl $0x2f, -0xc(%rbp)
jmp 0x201f
leaq 0x466d(%rip), %rax      # 0x6660
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x4661(%rip), %rax      # 0x6660
movl %ecx, (%rax)
leaq 0x4138(%rip), %rax      # 0x6140
movq (%rax), %rdi
callq 0x1110
movq %rax, %rcx
leaq 0x4e56(%rip), %rax      # 0x6e70
movq %rcx, (%rax)
jmp 0x201f
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x2035
cmpl $0x0, -0x10(%rbp)
jne 0x2035
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2047
movl $0x0, -0x10(%rbp)
jmp 0x1f19
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0x243a
movslq -0x4(%rbp), %rcx
leaq 0x3d71(%rip), %rax      # 0x6160
movb $0x0, (%rax,%rcx)
movslq -0x4(%rbp), %rcx
leaq 0x3e62(%rip), %rax      # 0x6260
movb $0x0, (%rax,%rcx)
movslq -0x4(%rbp), %rcx
leaq 0x3f53(%rip), %rax      # 0x6360
movb $0x0, (%rax,%rcx)
movslq -0x4(%rbp), %rcx
leaq 0x4044(%rip), %rax      # 0x6460
movb $0x0, (%rax,%rcx)
movslq -0x4(%rbp), %rcx
leaq 0x4135(%rip), %rax      # 0x6560
movb $0x1, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x23db
leaq 0x1ded(%rip), %rax      # 0x422e
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2470
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x4002(%rip), %rax      # 0x6460
movb $0x1, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2445
leaq 0x1dbc(%rip), %rax      # 0x4233
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x24a6
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x3ecc(%rip), %rax      # 0x6360
movb $0x1, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x247b
leaq 0x1da5(%rip), %rax      # 0x4252
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x24dc
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x3d96(%rip), %rax      # 0x6260
movb $0x1, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x24b1
leaq 0x1daf(%rip), %rax      # 0x4292
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2512
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x3c60(%rip), %rax      # 0x6160
movb $0x1, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x24e7
leaq 0x1daf(%rip), %rax      # 0x42c8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2548
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x402a(%rip), %rax      # 0x6560
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x251d
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, 0x40fa(%rip)      # 0x6660
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
callq 0x10c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x26c2
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x6c, %eax
jne 0x2638
movq -0x10(%rbp), %rax
cmpb $0x0, 0x2(%rax)
jne 0x2638
jmp 0x25a3
movq 0x3b96(%rip), %rdi      # 0x6140
callq 0x11b0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x25bc
jmp 0x26c7
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x3e98(%rip), %rax      # 0x6460
cmpb $0x0, (%rax,%rcx)
jne 0x25dc
movq 0x3b6b(%rip), %rdi      # 0x6140
callq 0x10b0
jmp 0x25de
jmp 0x25a3
movl -0x14(%rbp), %esi
leaq 0x1ce3(%rip), %rdi      # 0x42cb
callq 0x1080
cmpq $0x0, %rax
je 0x25fd
callq 0x2c80
jmp 0x26c7
callq 0x3940
leaq 0x4067(%rip), %rdi      # 0x6670
leaq 0x1cbf(%rip), %rsi      # 0x42cf
callq 0x1040
movl 0x4045(%rip), %esi      # 0x6660
leaq 0x1cb1(%rip), %rdi      # 0x42d3
callq 0x32f0
movq 0x3b12(%rip), %rdi      # 0x6140
callq 0x10b0
jmp 0x26c0
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x79, %eax
jne 0x2680
movq -0x10(%rbp), %rax
cmpb $0x0, 0x2(%rax)
jne 0x2680
callq 0x3940
leaq 0x4015(%rip), %rdi      # 0x6670
leaq 0x1c6d(%rip), %rsi      # 0x42cf
callq 0x1040
movl 0x3ff3(%rip), %esi      # 0x6660
leaq 0x1c65(%rip), %rdi      # 0x42d9
callq 0x32f0
callq 0x3680
jmp 0x26be
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x63, %eax
je 0x26bc
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x68, %eax
je 0x26bc
movq -0x10(%rbp), %rax
cmpb $0x0, 0x2(%rax)
jne 0x26bc
callq 0x26d0
cmpl $0x0, %eax
je 0x26b0
jmp 0x26c7
movq 0x3a89(%rip), %rdi      # 0x6140
callq 0x10b0
jmp 0x26be
jmp 0x26c0
jmp 0x26c2
callq 0x12d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq 0x43a2(%rip), %rax      # 0x6e78
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x2b12
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $-0x21, %eax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movsbl (%rcx), %ecx
andl $-0x21, %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x2b1b
jmp 0x2b34
jmp 0x2b1d
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2ada
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x2b5d
movl -0x14(%rbp), %ecx
movq 0x4331(%rip), %rax      # 0x6e78
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x4324(%rip)      # 0x6e78
movl $0x1, -0x4(%rbp)
jmp 0x2b64
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
jmp 0x2b76
callq 0x11c0
movq (%rax), %rax
movq 0x42f3(%rip), %rcx      # 0x6e78
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x2baf
jmp 0x2b9b
movq 0x42d6(%rip), %rax      # 0x6e78
addq $0x1, %rax
movq %rax, 0x42cb(%rip)      # 0x6e78
jmp 0x2b76
movq 0x42c2(%rip), %rax      # 0x6e78
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x2c7e
movq 0x42af(%rip), %rax      # 0x6e78
addq $0x1, %rax
movq %rax, 0x42a4(%rip)      # 0x6e78
callq 0x11c0
movq (%rax), %rax
movq 0x4295(%rip), %rcx      # 0x6e78
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x2c0d
jmp 0x2bf9
movq 0x4278(%rip), %rax      # 0x6e78
addq $0x1, %rax
movq %rax, 0x426d(%rip)      # 0x6e78
jmp 0x2bd4
callq 0x11c0
movq (%rax), %rax
movq 0x425c(%rip), %rcx      # 0x6e78
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x2c44
movq 0x4241(%rip), %rax      # 0x6e78
addq $-0x1, %rax
movq %rax, 0x4236(%rip)      # 0x6e78
jmp 0x2c7c
jmp 0x2c46
callq 0x11c0
movq (%rax), %rax
movq 0x4223(%rip), %rcx      # 0x6e78
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x4215(%rip)      # 0x6e78
movsbl 0x1(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x2c7a
jmp 0x2c46
jmp 0x2c7c
jmp 0x2c7e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3202
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x31e0
leaq 0x2f2f(%rip), %rax      # 0x6138
cmpl $0x0, (%rax)
je 0x324d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
addl $0x3f, %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x10(%rbp), %rdx
movl %eax, %ecx
leaq 0x115d(%rip), %rdi      # 0x439e
movb $0x0, %al
callq 0x1090
jmp 0x32d2
leaq 0x2ee8(%rip), %rax      # 0x613c
cmpl $0x0, (%rax)
je 0x3288
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %r8
leaq 0x1129(%rip), %rdi      # 0x43a8
movb $0x0, %al
callq 0x1090
jmp 0x32d0
leaq 0x2ec9(%rip), %rax      # 0x6158
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x2e63(%rip), %rax      # 0x610c
movsbl (%rax), %r8d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %r9
leaq 0x2e50(%rip), %rax      # 0x610c
movsbl (%rax), %eax
leaq 0x10f5(%rip), %rsi      # 0x43bb
movl %eax, (%rsp)
movb $0x0, %al
callq 0x1100
jmp 0x32d2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x32ea
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x31e0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3531
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x351b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x34f0
movq -0x8(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x34fc
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x10f0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x3618
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x35c6
leaq 0x2ba9(%rip), %rax      # 0x6134
cmpl $0x0, (%rax)
jne 0x35c1
movq 0x2a61(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x30b7(%rip), %rax      # 0x6660
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %r8
leaq 0xe46(%rip), %rsi       # 0x4400
movb $0x0, %al
callq 0x1100
jmp 0x3675
movq -0x10(%rbp), %rax
cmpb $0x0, 0x2c(%rax)
jne 0x360e
leaq 0x2b5d(%rip), %rax      # 0x6134
cmpl $0x0, (%rax)
jne 0x360c
movq 0x2a15(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %r8
leaq 0xe39(%rip), %rsi       # 0x443e
movb $0x0, %al
callq 0x1100
jmp 0x360e
movq -0x10(%rbp), %rax
movb $0x1, 0x2c(%rax)
jmp 0x3675
cmpl $0x0, -0x14(%rbp)
jge 0x3647
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x363a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x3540
jmp 0x3645
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3673
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3665
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3540
jmp 0x3671
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3673
jmp 0x3675
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x27f1(%rip), %rax      # 0x6140
movq (%rax), %rdi
callq 0x1110
movq %rax, %rcx
leaq 0x350f(%rip), %rax      # 0x6e70
movq %rcx, (%rax)
movl $0x0, -0x8(%rbp)
leaq 0x27ce(%rip), %rax      # 0x6140
movq (%rax), %rdi
callq 0x11b0
movl %eax, -0x4(%rbp)
cmpl $-0x1, %eax
je 0x39f8
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0xa, %eax
je 0x3999
jmp 0x398f
movl -0xc(%rbp), %eax
subl $0x25, %eax
je 0x39db
jmp 0x39ec
leaq 0x2cc0(%rip), %rax      # 0x6660
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x2cb4(%rip), %rax      # 0x6660
movl %ecx, (%rax)
leaq 0x278b(%rip), %rax      # 0x6140
movq (%rax), %rdi
callq 0x1110
movq %rax, %rcx
leaq 0x34a9(%rip), %rax      # 0x6e70
movq %rcx, (%rax)
cmpl $0x3, -0x8(%rbp)
jne 0x39d2
jmp 0x39f8
movl $0x1, -0x8(%rbp)
jmp 0x39f3
cmpl $0x0, -0x8(%rbp)
je 0x39ea
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x39f3
movl $0x0, -0x8(%rbp)
jmp 0x396b
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x8, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x151c
movq -0x20(%rbp), %rcx
leaq 0x2b6f(%rip), %rax      # 0x4060
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x1050
cmpl $0x0, %eax
jne 0x150c
movl $0x1, -0x4(%rbp)
jmp 0x1523
jmp 0x150e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x14dc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1340
cmpl $0x2a, %eax
jne 0x1554
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x153f
callq 0x17f0
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
je 0x157e
leaq 0x2b50(%rip), %rdi      # 0x40c0
leaq 0xb5f(%rip), %rsi       # 0x20d6
callq 0x1070
jmp 0x1559
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x27cdd(%rip), %rdi     # 0x2a004
movb $0x0, %al
callq 0x2040
leaq 0x27cf3(%rip), %rdi     # 0x2a028
movb $0x0, %al
callq 0x2040
leaq 0x27ced(%rip), %rdi     # 0x2a030
movb $0x0, %al
callq 0x2040
leaq 0x27d0c(%rip), %rdi     # 0x2a05d
movb $0x0, %al
callq 0x2040
leaq 0x27d29(%rip), %rdi     # 0x2a088
movb $0x0, %al
callq 0x2040
leaq 0x27d3b(%rip), %rdi     # 0x2a0a8
movb $0x0, %al
callq 0x2040
leaq 0x27d60(%rip), %rdi     # 0x2a0db
movb $0x0, %al
callq 0x2040
leaq 0x27d75(%rip), %rdi     # 0x2a0fe
movb $0x0, %al
callq 0x2040
leaq 0x27d95(%rip), %rdi     # 0x2a12c
movb $0x0, %al
callq 0x2040
leaq 0x27dae(%rip), %rdi     # 0x2a153
movb $0x0, %al
callq 0x2040
leaq 0x27dd7(%rip), %rdi     # 0x2a18a
movb $0x0, %al
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movl $0x0, -0x14(%rbp)
movl %edi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movl $0x0, -0x64(%rbp)
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
leaq -0x40(%rbp), %r9
leaq -0x48(%rbp), %r14
leaq -0x50(%rbp), %rbx
leaq -0x58(%rbp), %r11
leaq -0x60(%rbp), %r10
leaq -0x64(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x23c0
movl %eax, -0x68(%rbp)
cmpl $0x0, -0x68(%rbp)
je 0x2e7c
movl -0x68(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x2ece
cmpl $0x0, -0x64(%rbp)
je 0x2e97
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x2310
movl $0x0, -0x14(%rbp)
jmp 0x2ece
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %r8
movq -0x50(%rbp), %r9
movq -0x58(%rbp), %r10
movq -0x60(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x27a0
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xe97(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
leaq 0xe94(%rip), %rdi       # 0x200f
leaq -0x14(%rbp), %rsi
movb $0x0, %al
callq 0x1040
movl -0x14(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
cmpl $0x0, %eax
jne 0x11b6
movl -0x14(%rbp), %ecx
leaq 0xe72(%rip), %rdi       # 0x2012
leaq 0xe77(%rip), %rdx       # 0x201e
movq %rdx, %rsi
movb $0x0, %al
callq 0x1030
jmp 0x1251
movl -0x14(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
cmpl $0x3c, %eax
jge 0x11fe
movl -0x14(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl -0x28(%rbp), %edx
leaq 0xe36(%rip), %rdi       # 0x2021
leaq 0xe2c(%rip), %rsi       # 0x201e
movb $0x0, %al
callq 0x1030
movl %eax, -0x24(%rbp)
jmp 0x124e
movl -0x14(%rbp), %eax
movl $0xe10, %ecx            # imm = 0xE10
cltd
idivl %ecx
movl %eax, %esi
movl -0x14(%rbp), %eax
movl $0xe10, %ecx            # imm = 0xE10
cltd
idivl %ecx
movl %edx, %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, -0x2c(%rbp)
movl -0x14(%rbp), %eax
movl $0xe10, %ecx            # imm = 0xE10
cltd
idivl %ecx
movl %edx, %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl -0x2c(%rbp), %edx
leaq 0xdeb(%rip), %rdi       # 0x202f
movb $0x0, %al
callq 0x1030
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x10(%rbp)
movl 0x24be(%rip), %eax      # 0x412c
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x24b3(%rip)      # 0x412c
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
shll $0x2, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x20(%rbp), %ecx
movb %al, -0x21(%rbp)
jge 0x1cad
cmpl $0x0, 0x2483(%rip)      # 0x4128
setne %al
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1cb6
jmp 0x1d1d
movl -0x20(%rbp), %eax
subl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rcx
leaq 0x23cb(%rip), %rax      # 0x40a0
movl (%rax,%rcx,4), %eax
cmpl 0x2402(%rip), %eax      # 0x40e0
jne 0x1cec
movl $0x1, 0x243e(%rip)      # 0x4128
jmp 0x1d1d
movslq -0x18(%rbp), %rcx
leaq 0x23a9(%rip), %rax      # 0x40a0
movl (%rax,%rcx,4), %eax
cmpl 0x23e0(%rip), %eax      # 0x40e0
jle 0x1d0d
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1d16
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1d18
jmp 0x1c91
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1210
movl $0x0, -0x34(%rbp)
cmpl $0x4, -0x34(%rbp)
jge 0x1d7b
movslq -0x34(%rbp), %rax
leaq -0x30(%rbp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
leaq -0x107(%rip), %rsi      # 0x1c60
xorl %eax, %eax
movl %eax, %edx
callq 0x1630
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1d4b
movl $0x0, -0x38(%rbp)
cmpl $0x4, -0x38(%rbp)
jge 0x1da5
movslq -0x38(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x17f0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1d82
movl 0x237d(%rip), %eax      # 0x4128
cmpl 0x2333(%rip), %eax      # 0x40e4
jne 0x1dc3
leaq 0x277(%rip), %rdi       # 0x2031
movb $0x0, %al
callq 0x1070
jmp 0x1dd1
leaq 0x2a4(%rip), %rdi       # 0x206e
movb $0x0, %al
callq 0x1070
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
seta %al
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x1fa0
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x18(%rbp)
cvttsd2si -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
testb $0x1, -0x19(%rbp)
je 0x1fb8
xorl %eax, %eax
subl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x1fbe
movl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0xc(%rbp)
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0x20(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd 0x9076(%rip), %xmm1     # 0xb050
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x8(%rbp)
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0x20(%rbp), %xmm1
subsd %xmm1, %xmm0
movl -0x8(%rbp), %eax
imull $0x3c, %eax, %eax
cvtsi2sd %eax, %xmm1
movsd 0x9053(%rip), %xmm2     # 0xb058
mulsd %xmm2, %xmm0
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movss -0x28(%rbp), %xmm0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, %rax
movq %rax, -0x8(%rbp)
xorl %esi, %esi
movl $0x70, %edx
callq 0x10a0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0xcfd2(%rip), %rcx      # 0xf110
movq %rcx, 0x58(%rdi)
movq 0xcfcf(%rip), %rcx      # 0xf118
movq %rcx, 0x60(%rdi)
movq 0xcfbc(%rip), %rcx      # 0xf110
movq %rcx, 0x28(%rdi)
movq 0xcfb9(%rip), %rcx      # 0xf118
movq %rcx, 0x30(%rdi)
movq 0xcfa6(%rip), %rcx      # 0xf110
movq %rcx, 0x18(%rdi)
movq 0xcfa3(%rip), %rcx      # 0xf118
movq %rcx, 0x20(%rdi)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
callq 0x3970
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
leaq 0x8ee1(%rip), %rsi      # 0xb5cd
movb $0x2, %al
callq 0x40e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
xorl %edi, %edi
callq 0x21c0
andb $0x1, %al
movb %al, -0x31(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3a10
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2748
jmp 0x281a
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq -0x8(%rbp), %rdx
movslq 0x24(%rdx), %rdx
imulq $0xe8, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x27c4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11f8
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0x11f8
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rdi
callq 0x11f8
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rdi
callq 0x11f8
movq -0x10(%rbp), %rax
addq $0xe8, %rax
movq %rax, -0x10(%rbp)
jmp 0x2754
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x11f8
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x5430
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3a10
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x28a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x286f
movq -0x28(%rbp), %rdi
callq 0x7f80
cmpl $0x0, %eax
jne 0x286f
movq -0x28(%rbp), %rdi
callq 0x52e0
cmpl $0x0, %eax
jne 0x2880
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x2893
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x28c4
movq $0x0, -0x8(%rbp)
jmp 0x29a5
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1070
movq -0x40(%rbp), %rdi
movl %eax, %esi
movq 0xc837(%rip), %rdx      # 0xf120
movl $0x1, %ecx
leaq -0x1c(%rbp), %r8
callq 0x45b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x290f
movq $0x0, -0x8(%rbp)
jmp 0x29a5
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x41(%rbp)
jge 0x2936
cmpq $0x0, -0x30(%rbp)
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x293f
jmp 0x2991
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3760
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jl 0x296b
movq -0x30(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x61f0
movq %rax, -0x30(%rbp)
jmp 0x2984
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x63f0
movq %rax, -0x30(%rbp)
jmp 0x2986
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x291e
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x47e0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x28a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x29ff
movq -0x28(%rbp), %rdi
callq 0x7f80
cmpl $0x0, %eax
jne 0x29ff
movq -0x28(%rbp), %rdi
callq 0x7fc0
cmpl $0x0, %eax
jne 0x2a0f
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x2a20
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movq -0x28(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x28a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2a7f
movq -0x28(%rbp), %rdi
callq 0x7f80
cmpl $0x0, %eax
jne 0x2a7f
movq -0x28(%rbp), %rdi
callq 0x7fc0
cmpl $0x0, %eax
jne 0x2a90
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2aa5
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movq -0x28(%rbp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq