LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/global_basic.c
// Function: nextPrime
int nextPrime(int n){
    int j;
    int tag = 0;
    while (1){
        for(j=2;j<=(int)sqrt(n);j++){
            if(n%j == 0){
                tag = 1;
                break;
            }
        }
        if(tag == 1){
            if(n == 0x7FFFFFFF){
                printf("[ERROR] n exceed 0x7FFFFFFF, Can't find a valid prime\n");
                exit(1);
            }
            n++;
            tag = 0;
        }else{
            return n;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x2, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
callq 0x3430
movl -0x10(%rbp), %eax
cvttsd2si %xmm0, %ecx
cmpl %ecx, %eax
jg 0x17cc6
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
cmpl $0x0, %edx
jne 0x17cb9
movl $0x1, -0xc(%rbp)
jmp 0x17cc6
jmp 0x17cbb
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x17c89
cmpl $0x1, -0xc(%rbp)
jne 0x17cff
cmpl $0x7fffffff, -0x4(%rbp) # imm = 0x7FFFFFFF
jne 0x17ced
leaq 0x718f(%rip), %rdi      # 0x1ee6b
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x3410
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
jmp 0x17d08
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
jmp 0x17c82
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/kssd.c
// Function: main
int main(int argc, char** argv)
{
  setvbuf(stdout, (char *)NULL, _IOLBF, 0);
  setvbuf(stderr, (char *)NULL, _IOLBF, 0);
 const char subcommand_n[] = "<subcommand>";
  domain = (char*) malloc(strlen(argv[0])+1);
  strcpy(domain,argv[0]);
  long_domain = (char*) malloc( strlen(domain) + strlen(subcommand_n) + 1);
  snprintf(long_domain,strlen(domain) + strlen(subcommand_n) + 2,"%s %s",domain,subcommand_n);
  cmd_global(argc, argv);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x6e2b(%rip), %rax      # 0x21fd8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
movq %rcx, %rsi
callq 0x3340
movq 0x6e30(%rip), %rax      # 0x21ff8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
movq %rcx, %rsi
callq 0x3340
movq 0x4030(%rip), %rax      # 0x1f213
movq %rax, -0x1d(%rbp)
movl 0x402e(%rip), %eax      # 0x1f21b
movl %eax, -0x15(%rbp)
movb 0x4029(%rip), %al       # 0x1f21f
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3110
movq %rax, %rdi
addq $0x1, %rdi
callq 0x3310
movq %rax, %rcx
leaq 0x493d5(%rip), %rax     # 0x645f0
movq %rcx, (%rax)
leaq 0x493cb(%rip), %rax     # 0x645f0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x3070
leaq 0x493b5(%rip), %rax     # 0x645f0
movq (%rax), %rdi
callq 0x3110
movq %rax, %rdi
addq $0xc, %rdi
addq $0x1, %rdi
callq 0x3310
movq %rax, %rcx
leaq 0x4939b(%rip), %rax     # 0x645f8
movq %rcx, (%rax)
leaq 0x49391(%rip), %rax     # 0x645f8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0x4937b(%rip), %rax     # 0x645f0
movq (%rax), %rdi
callq 0x3110
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0xc, %rsi
addq $0x2, %rsi
leaq 0x4935d(%rip), %rax     # 0x645f0
movq (%rax), %rcx
leaq -0x1d(%rbp), %r8
leaq 0x3d45(%rip), %rdx      # 0x1efe6
movb $0x0, %al
callq 0x3190
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x17d10
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/yhg926[P]public_kssd/mytime.c
// Function: diff
struct timespec diff(struct timespec start, struct timespec end)
{
        struct timespec temp;
        if ((end.tv_nsec - start.tv_nsec) < 0)
        {
                temp.tv_sec = end.tv_sec - start.tv_sec - 1;
                temp.tv_nsec = 1000000000 + end.tv_nsec - start.tv_nsec;
        }
        else
        {
                temp.tv_sec = end.tv_sec - start.tv_sec;
                temp.tv_nsec = end.tv_nsec - start.tv_nsec;
        }
        return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
subq -0x18(%rbp), %rax
cmpq $0x0, %rax
jge 0x1b376
movq -0x30(%rbp), %rax
subq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
addq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
subq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b38e
movq -0x30(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mgrosvenor[P]evec/demo1.c
// Function: main
int main(int argc, char** argv)
{
    int* a = NULL;
    evpsh(a, 2);
    evpsh(a, 4);
    evpsh(a, 6);

    for(int i =0; i < evcnt(a); i++){
        printf("%i: %i\n", i, a[i]);
    }

    a = evfree(a);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x2, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0x1910
movq %rax, -0x18(%rbp)
jmp 0x1fad
movl $0x4, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0x1910
movq %rax, -0x18(%rbp)
jmp 0x1fcc
movl $0x6, -0x24(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movl $0x4, %edx
callq 0x1910
movq %rax, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movslq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a70
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x2034
movl -0x28(%rbp), %esi
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x137c(%rip), %rdi      # 0x339e
movb $0x0, %al
callq 0x1050
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1ff0
movq -0x18(%rbp), %rdi
callq 0x1ee0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/btree_test2.c
// Function: main
int main()
{
    uint64_t       k, n;
    BTree         *bt;
    BTreeOpenFlag  flag;
    BTreeValues   *values;

    
    flag.create_if_missing = 1;
    flag.error_if_exist = 0;
    flag.file = "./test.bt";
    flag.order = 501;

    bt = bt_open(flag);
    //bt_print(bt);

    n = 544;

    printf("插入1000000个随机的 key/value pair...");
    for(k=0;k<1000000;k++)
    {
        n = rand() % 1000000;
        bt_insert(bt, n, n);
        if(n<10)
        {
            printf("\tinsert (%ld, %ld)\n", n, n);
        }
        //bt_insert(bt, rand(), rand());
        //bt_print(bt);
    }
    printf("Insert done.\n");
    
    printf("搜索 [0, 10] 范围的 key...\n");
    values = bt_search_range(bt, 100, 0, 10);
    printf("\tSearch Result[%lu]: ", bt_values_get_count(values));
    for(k=0;k<bt_values_get_count(values); k++)
        printf("%lu ", bt_values_get_value(values, k));
    printf("\n");
    bt_values_destory(values);

    printf("Search done.\n");
    bt_close(bt);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl $0x1, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
leaq 0xbc4(%rip), %rax       # 0x4978
movq %rax, -0x38(%rbp)
movq $0x1f5, -0x30(%rbp)     # imm = 0x1F5
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1d50
movq %rax, -0x20(%rbp)
movq $0x220, -0x18(%rbp)     # imm = 0x220
leaq 0xb8d(%rip), %rdi       # 0x4982
movb $0x0, %al
callq 0x1070
movq $0x0, -0x10(%rbp)
cmpq $0xf4240, -0x10(%rbp)   # imm = 0xF4240
jae 0x3e60
callq 0x1120
movl $0xf4240, %ecx          # imm = 0xF4240
cltd
idivl %ecx
movslq %edx, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1a50
cmpq $0xa, -0x18(%rbp)
jae 0x3e50
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0xb65(%rip), %rdi       # 0x49ae
movb $0x0, %al
callq 0x1070
jmp 0x3e52
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3e04
leaq 0xb5b(%rip), %rdi       # 0x49c2
movb $0x0, %al
callq 0x1070
leaq 0xb5b(%rip), %rdi       # 0x49d0
movb $0x0, %al
callq 0x1070
movq -0x20(%rbp), %rdi
movl $0x64, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0xa, %ecx
callq 0x1c30
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x17a0
movq %rax, %rsi
leaq 0xb47(%rip), %rdi       # 0x49f1
movb $0x0, %al
callq 0x1070
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x17a0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x3f02
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x17c0
movq %rax, %rsi
leaq 0x3e6(%rip), %rdi       # 0x42d3
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3eb9
leaq 0xab7(%rip), %rdi       # 0x49c0
movb $0x0, %al
callq 0x1070
movq -0x40(%rbp), %rdi
callq 0x1770
leaq 0xae7(%rip), %rdi       # 0x4a07
movb $0x0, %al
callq 0x1070
movq -0x20(%rbp), %rdi
callq 0x2110
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zdump.c
// Function: usage
static void
usage(stream, status)
FILE * const	stream;
const int	status;
{
	(void) fprintf(stream,
_("%s: usage is %s [ --version ] [ --help ] [ -v ] [ -c [loyear,]hiyear ] zonename ...\n\
\n\
Report bugs to tz@elsie.nci.nih.gov.\n"),
		       progname, progname);
	exit(status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq 0x76b6(%rip), %rdx      # 0x9170
movq 0x76af(%rip), %rcx      # 0x9170
leaq 0x559e(%rip), %rsi      # 0x7066
movb $0x0, %al
callq 0x1120
movl -0xc(%rbp), %edi
callq 0x11f0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zdump.c
// Function: yeartot
static time_t
yeartot(y)
const long	y;
{
	register long	myy;
	register long	seconds;
	register time_t	t;

	myy = EPOCH_YEAR;
	t = 0;
	while (myy != y) {
		if (myy < y) {
			seconds = isleap(myy) ? SECSPERLYEAR : SECSPERNYEAR;
			++myy;
			if (t > absolute_max_time - seconds) {
				t = absolute_max_time;
				break;
			}
			t += seconds;
		} else {
			--myy;
			seconds = isleap(myy) ? SECSPERLYEAR : SECSPERNYEAR;
			if (t < absolute_min_time + seconds) {
				t = absolute_min_time;
				break;
			}
			t -= seconds;
		}
	}
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x7b2, -0x10(%rbp)     # imm = 0x7B2
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x1ce6
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jge 0x1c3d
movq -0x10(%rbp), %rax
movl $0x4, %ecx
cqto
idivq %rcx
xorl %eax, %eax
cmpq $0x0, %rdx
movb %al, -0x21(%rbp)
jne 0x1be4
movq -0x10(%rbp), %rax
movl $0x64, %ecx
cqto
idivq %rcx
movb $0x1, %al
cmpq $0x0, %rdx
movb %al, -0x22(%rbp)
jne 0x1bde
movq -0x10(%rbp), %rax
movl $0x190, %ecx            # imm = 0x190
cqto
idivq %rcx
cmpq $0x0, %rdx
sete %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %dl
movl $0x1e13380, %eax        # imm = 0x1E13380
movl $0x1e28500, %ecx        # imm = 0x1E28500
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq 0x797d(%rip), %rcx      # 0x9590
subq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jle 0x1c2c
movq 0x796d(%rip), %rax      # 0x9590
movq %rax, -0x20(%rbp)
jmp 0x1ce6
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1ce1
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x4, %ecx
cqto
idivq %rcx
xorl %eax, %eax
cmpq $0x0, %rdx
movb %al, -0x23(%rbp)
jne 0x1c99
movq -0x10(%rbp), %rax
movl $0x64, %ecx
cqto
idivq %rcx
movb $0x1, %al
cmpq $0x0, %rdx
movb %al, -0x24(%rbp)
jne 0x1c93
movq -0x10(%rbp), %rax
movl $0x190, %ecx            # imm = 0x190
cqto
idivq %rcx
cmpq $0x0, %rdx
sete %al
movb %al, -0x24(%rbp)
movb -0x24(%rbp), %al
movb %al, -0x23(%rbp)
movb -0x23(%rbp), %dl
movl $0x1e13380, %eax        # imm = 0x1E13380
movl $0x1e28500, %ecx        # imm = 0x1E28500
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x78cc(%rip), %rcx      # 0x9588
addq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jge 0x1cd2
movq 0x78bc(%rip), %rax      # 0x9588
movq %rax, -0x20(%rbp)
jmp 0x1ce6
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x1b78
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zdump.c
// Function: show
static void
show(char *zone, time_t t, int v)
{
	register struct tm *	tmp;

	(void) printf("%-*s  ", (int) longest, zone);
	if (v) {
		tmp = gmtime(&t);
		if (tmp == NULL) {
			(void) printf(tformat(), t);
		} else {
			dumptime(tmp);
			(void) printf(" UTC");
		}
		(void) printf(" = ");
	}
	tmp = my_localtime(&t);
	dumptime(tmp);
	if (tmp != NULL) {
		if (*abbr(tmp) != '\0')
			(void) printf(" %s", abbr(tmp));
		if (v) {
			(void) printf(" isdst=%d", tmp->tm_isdst);
#ifdef TM_GMTOFF
			(void) printf(" gmtoff=%ld", tmp->TM_GMTOFF);
#endif /* defined TM_GMTOFF */
		}
	}
	(void) printf("\n");
	if (tmp != NULL && *abbr(tmp) != '\0')
		abbrok(abbr(tmp), zone);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x746e(%rip), %rax      # 0x9178
movl %eax, %esi
movq -0x8(%rbp), %rdx
leaq 0x53ca(%rip), %rdi      # 0x70e1
movb $0x0, %al
callq 0x10d0
cmpl $0x0, -0x14(%rbp)
je 0x1d72
leaq -0x10(%rbp), %rdi
callq 0x43b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1d4d
callq 0x21f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movb $0x0, %al
callq 0x10d0
jmp 0x1d64
movq -0x20(%rbp), %rdi
callq 0x2200
leaq 0x538b(%rip), %rdi      # 0x70e8
movb $0x0, %al
callq 0x10d0
leaq 0x5382(%rip), %rdi      # 0x70ed
movb $0x0, %al
callq 0x10d0
leaq -0x10(%rbp), %rdi
callq 0x3fd0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2200
cmpq $0x0, -0x20(%rbp)
je 0x1dd7
movq -0x20(%rbp), %rdi
callq 0x1e20
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1dba
movq -0x20(%rbp), %rdi
callq 0x1e20
movq %rax, %rsi
leaq 0x533e(%rip), %rdi      # 0x70f1
movb $0x0, %al
callq 0x10d0
cmpl $0x0, -0x14(%rbp)
je 0x1dd5
movq -0x20(%rbp), %rax
movl 0x20(%rax), %esi
leaq 0x5327(%rip), %rdi      # 0x70f5
movb $0x0, %al
callq 0x10d0
jmp 0x1dd7
leaq 0x5301(%rip), %rdi      # 0x70df
movb $0x0, %al
callq 0x10d0
cmpq $0x0, -0x20(%rbp)
je 0x1e12
movq -0x20(%rbp), %rdi
callq 0x1e20
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1e12
movq -0x20(%rbp), %rdi
callq 0x1e20
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x23b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zdump.c
// Function: delta
static long
delta(newp, oldp)
struct tm *	newp;
struct tm *	oldp;
{
	register long	result;
	register int	tmy;

	if (newp->tm_year < oldp->tm_year)
		return -delta(oldp, newp);
	result = 0;
	for (tmy = oldp->tm_year; tmy < newp->tm_year; ++tmy)
		result += DAYSPERNYEAR + isleap_sum(tmy, TM_YEAR_BASE);
	result += newp->tm_yday - oldp->tm_yday;
	result *= HOURSPERDAY;
	result += newp->tm_hour - oldp->tm_hour;
	result *= MINSPERHOUR;
	result += newp->tm_min - oldp->tm_min;
	result *= SECSPERMIN;
	result += newp->tm_sec - oldp->tm_sec;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x1ece
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1e90
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x2007
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x1f86
movl -0x24(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
movl %edx, %eax
addl $0x12c, %eax            # imm = 0x12C
movl $0x4, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl $0x0, %edx
movb %al, -0x25(%rbp)
jne 0x1f61
movl -0x24(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
movl %edx, %eax
addl $0x12c, %eax            # imm = 0x12C
movl $0x64, %ecx
cltd
idivl %ecx
movb $0x1, %al
cmpl $0x0, %edx
movb %al, -0x26(%rbp)
jne 0x1f5b
movl -0x24(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
movl %edx, %eax
addl $0x12c, %eax            # imm = 0x12C
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
sete %al
movb %al, -0x26(%rbp)
movb -0x26(%rbp), %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addl $0x16d, %eax            # imm = 0x16D
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1ee0
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x1c(%rcx), %eax
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
imulq $0x18, -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x8(%rcx), %eax
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
imulq $0x3c, -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x4(%rcx), %eax
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
imulq $0x3c, -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
subl (%rcx), %eax
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/zdump.c
// Function: hunt
static time_t
hunt(char *name, time_t lot, time_t hit)
{
	time_t			t;
	long			diff;
	struct tm		lotm;
	register struct tm *	lotmp;
	struct tm		tm;
	register struct tm *	tmp;
	char			loab[MAX_STRING_LENGTH];

	lotmp = my_localtime(&lot);
	if (lotmp != NULL) {
		lotm = *lotmp;
		(void) strncpy(loab, abbr(&lotm), (sizeof loab) - 1);
	}
	for ( ; ; ) {
		diff = (long) (hit - lot);
		if (diff < 2)
			break;
		t = lot;
		t += diff / 2;
		if (t <= lot)
			++t;
		else if (t >= hit)
			--t;
		tmp = my_localtime(&t);
		if (tmp != NULL)
			tm = *tmp;
		if ((lotmp == NULL || tmp == NULL) ? (lotmp == tmp) :
			(delta(&tm, &lotm) == (t - lot) &&
			tm.tm_isdst == lotm.tm_isdst &&
			strcmp(abbr(&tm), loab) == 0)) {
				lot = t;
				lotm = tm;
				lotmp = tmp;
		} else	hit = t;
	}
	show(name, lot, TRUE);
	show(name, hit, TRUE);
	return hit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4c0, %rsp            # imm = 0x4C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3fd0
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x2088
movq -0x68(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movl $0x38, %edx
callq 0x1130
leaq -0x4b0(%rbp), %rax
movq %rax, -0x4b8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1e20
movq -0x4b8(%rbp), %rdi
movq %rax, %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x1060
jmp 0x208a
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x2, -0x28(%rbp)
jge 0x20a2
jmp 0x21be
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jg 0x20d8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x20f0
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jl 0x20ee
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x20f0
leaq -0x20(%rbp), %rdi
callq 0x3fd0
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
je 0x2122
movq -0xa8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movl $0x38, %edx
callq 0x1130
cmpq $0x0, -0x68(%rbp)
je 0x2133
cmpq $0x0, -0xa8(%rbp)
jne 0x2142
movq -0x68(%rbp), %rax
cmpq -0xa8(%rbp), %rax
je 0x2187
jmp 0x21b1
leaq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1e90
movq -0x20(%rbp), %rcx
subq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jne 0x21b1
movl -0x80(%rbp), %eax
cmpl -0x40(%rbp), %eax
jne 0x21b1
leaq -0xa0(%rbp), %rdi
callq 0x1e20
movq %rax, %rdi
leaq -0x4b0(%rbp), %rsi
callq 0x1110
cmpl $0x0, %eax
jne 0x21b1
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0x38, %edx
callq 0x1130
movq -0xa8(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x21b9
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x208a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x1cf0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x1cf0
movq -0x18(%rbp), %rax
addq $0x4c0, %rsp            # imm = 0x4C0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/localtime.c
// Function: tzset
void
tzset(void)
{
	register const char *	name;

	name = getenv("TZ");
	if (name == NULL) {
		tzsetwall();
		return;
	}

	if (lcl_is_set > 0 && strcmp(lcl_TZname, name) == 0)
		return;
	lcl_is_set = strlen(name) < sizeof lcl_TZname;
	if (lcl_is_set)
		(void) strcpy(lcl_TZname, name);

#ifdef ALL_STATE
	if (lclptr == NULL) {
		lclptr = (struct state *) calloc(1, sizeof *lclptr);
		if (lclptr == NULL) {
			settzname();	/* all we can do */
			return;
		}
	}
#endif /* defined ALL_STATE */
	if (*name == '\0') {
		/*
		** User wants it fast rather than right.
		*/
		lclptr->leapcnt = 0;		/* so, we're off a little */
		lclptr->timecnt = 0;
		lclptr->typecnt = 0;
		lclptr->ttis[0].tt_isdst = 0;
		lclptr->ttis[0].tt_gmtoff = 0;
		lclptr->ttis[0].tt_abbrind = 0;
		(void) strcpy(lclptr->chars, gmt);
	} else if (tzload(name, lclptr, TRUE) != 0)
		if (name[0] == ':' || tzparse(name, lclptr, FALSE) != 0)
			(void) gmtload(lclptr);
	settzname();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4c71(%rip), %rdi      # 0x7220
callq 0x1030
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x25c9
callq 0x26e0
jmp 0x26d2
cmpl $0x0, 0x6fd0(%rip)      # 0x95a0
jle 0x25ec
movq -0x8(%rbp), %rsi
leaq 0x6fd3(%rip), %rdi      # 0x95b0
callq 0x1110
cmpl $0x0, %eax
jne 0x25ec
jmp 0x26d2
movq -0x8(%rbp), %rdi
callq 0x10a0
cmpq $0x100, %rax            # imm = 0x100
setb %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x6f97(%rip)      # 0x95a0
cmpl $0x0, 0x6f90(%rip)      # 0x95a0
je 0x2622
movq -0x8(%rbp), %rsi
leaq 0x6f93(%rip), %rdi      # 0x95b0
callq 0x1080
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2680
movl $0x0, 0x7078(%rip)      # 0x96b0
movl $0x0, 0x7072(%rip)      # 0x96b4
movl $0x0, 0x706c(%rip)      # 0x96b8
movl $0x0, 0x9aaa(%rip)      # 0xc100
movq $0x0, 0x9a97(%rip) # 0xc0f8
movl $0x0, 0x9a99(%rip)      # 0xc104
leaq 0xb286(%rip), %rdi      # 0xd8f8
leaq 0x4c67(%rip), %rsi      # 0x72e0
callq 0x1080
jmp 0x26cd
movq -0x8(%rbp), %rdi
leaq 0x7025(%rip), %rsi      # 0x96b0
movl $0x1, %edx
callq 0x2730
cmpl $0x0, %eax
je 0x26cb
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
je 0x26bd
movq -0x8(%rbp), %rdi
leaq 0x6fff(%rip), %rsi      # 0x96b0
xorl %edx, %edx
callq 0x3320
cmpl $0x0, %eax
je 0x26c9
leaq 0x6fec(%rip), %rdi      # 0x96b0
callq 0x3df0
jmp 0x26cb
jmp 0x26cd
callq 0x3e40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/localtime.c
// Function: tzsetwall
void
tzsetwall(void)
{
	if (lcl_is_set < 0)
		return;
	lcl_is_set = -1;

#ifdef ALL_STATE
	if (lclptr == NULL) {
		lclptr = (struct state *) calloc(1, sizeof *lclptr);
		if (lclptr == NULL) {
			settzname();	/* all we can do */
			return;
		}
	}
#endif /* defined ALL_STATE */
	if (tzload((char *) NULL, lclptr, TRUE) != 0)
		gmtload(lclptr);
	settzname();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x6eb5(%rip)      # 0x95a0
jge 0x26ef
jmp 0x2724
movl $0xffffffff, 0x6ea7(%rip) # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edi
leaq 0x6fac(%rip), %rsi      # 0x96b0
movl $0x1, %edx
callq 0x2730
cmpl $0x0, %eax
je 0x271f
leaq 0x6f96(%rip), %rdi      # 0x96b0
callq 0x3df0
callq 0x3e40
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/localtime.c
// Function: detzcode
static long
detzcode(codep)
const char * const	codep;
{
	register long	result;
	register int	i;

	result = (codep[0] & 0x80) ? ~0L : 0;
	for (i = 0; i < 4; ++i)
		result = (result << 8) | (codep[i] & 0xff);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %edx
andl $0x80, %edx
xorl %eax, %eax
movq $-0x1, %rcx
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x4865
movq -0x10(%rbp), %rax
shlq $0x8, %rax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
andl $0xff, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4830
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/localtime.c
// Function: detzcode64
static time_t
detzcode64(codep)
const char * const	codep;
{
	register time_t	result;
	register int	i;

	result = (codep[0] & 0x80) ?  (~(int_fast64_t) 0) : 0;
	for (i = 0; i < 8; ++i)
		result = result * 256 + (codep[i] & 0xff);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %edx
andl $0x80, %edx
xorl %eax, %eax
movq $-0x1, %rcx
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x48d5
movq -0x10(%rbp), %rax
shlq $0x8, %rax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
andl $0xff, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x48a0
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/localtime.c
// Function: typesequiv
static int
typesequiv(sp, a, b)
const struct state * const	sp;
const int			a;
const int			b;
{
	register int	result;

	if (sp == NULL ||
		a < 0 || a >= sp->typecnt ||
		b < 0 || b >= sp->typecnt)
			result = FALSE;
	else {
		register const struct ttinfo *	ap = &sp->ttis[a];
		register const struct ttinfo *	bp = &sp->ttis[b];
		result = ap->tt_gmtoff == bp->tt_gmtoff &&
			ap->tt_isdst == bp->tt_isdst &&
			ap->tt_ttisstd == bp->tt_ttisstd &&
			ap->tt_ttisgmt == bp->tt_ttisgmt &&
			strcmp(&sp->chars[ap->tt_abbrind],
			&sp->chars[bp->tt_abbrind]) == 0;
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x491d
cmpl $0x0, -0xc(%rbp)
jl 0x491d
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x491d
cmpl $0x0, -0x10(%rbp)
jl 0x491d
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x4929
movl $0x0, -0x14(%rbp)
jmp 0x49f4
movq -0x8(%rbp), %rax
addq $0x2a48, %rax           # imm = 0x2A48
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x2a48, %rax           # imm = 0x2A48
movslq -0x10(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x29(%rbp)
jne 0x49e9
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x28(%rbp), %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, -0x29(%rbp)
jne 0x49e9
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x28(%rbp), %rdx
xorl %eax, %eax
cmpl 0x10(%rdx), %ecx
movb %al, -0x29(%rbp)
jne 0x49e9
movq -0x20(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x28(%rbp), %rdx
xorl %eax, %eax
cmpl 0x14(%rdx), %ecx
movb %al, -0x29(%rbp)
jne 0x49e9
movq -0x8(%rbp), %rdi
addq $0x4248, %rdi           # imm = 0x4248
movq -0x20(%rbp), %rax
movslq 0xc(%rax), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x4248, %rsi           # imm = 0x4248
movq -0x28(%rbp), %rax
movslq 0xc(%rax), %rax
addq %rax, %rsi
callq 0x1110
cmpl $0x0, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/localtime.c
// Function: getqzname
static const char *
getqzname(register const char *strp, const int delim)
{
	register int	c;

	while ((c = *strp) != '\0' && c != delim)
		++strp;
	return strp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
movl %ecx, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x4a5b
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x4a64
jmp 0x4a72
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x4a3b
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/localtime.c
// Function: increment_overflow
static int
increment_overflow(ip, j)
int * const	ip;
int		j;
{
	register int const	i = *ip;

	/*
	** If i >= 0 there can only be overflow if i + j > INT_MAX
	** or if j > INT_MAX - i; given i >= 0, INT_MAX - i cannot overflow.
	** If i < 0 there can only be overflow if i + j < INT_MIN
	** or if j < INT_MIN - i; given i < 0, INT_MIN - i cannot overflow.
	*/
	if ((i >= 0) ? (j > INT_MAX - i) : (j < INT_MIN - i))
		return TRUE;
	*ip += j;
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x5a0b
movl -0x14(%rbp), %eax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
subl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jg 0x5a1a
jmp 0x5a23
movl -0x14(%rbp), %eax
movl $0x80000000, %ecx       # imm = 0x80000000
subl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x5a23
movl $0x1, -0x4(%rbp)
jmp 0x5a35
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/localtime.c
// Function: normalize_overflow
static int
normalize_overflow(tensptr, unitsptr, base)
int * const	tensptr;
int * const	unitsptr;
const int	base;
{
	register int	tensdelta;

	tensdelta = (*unitsptr >= 0) ?
		(*unitsptr / base) :
		(-1 - (-1 - *unitsptr) / base);
	*unitsptr -= tensdelta * base;
	return increment_overflow(tensptr, tensdelta);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x635b
movq -0x10(%rbp), %rax
movl (%rax), %eax
cltd
idivl -0x14(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x6376
movq -0x10(%rbp), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subl (%rcx), %eax
cltd
idivl -0x14(%rbp)
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edx
imull -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x59e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/localtime.c
// Function: long_normalize_overflow
static int
long_normalize_overflow(tensptr, unitsptr, base)
long * const	tensptr;
int * const	unitsptr;
const int	base;
{
	register int	tensdelta;

	tensdelta = (*unitsptr >= 0) ?
		(*unitsptr / base) :
		(-1 - (-1 - *unitsptr) / base);
	*unitsptr -= tensdelta * base;
	return long_increment_overflow(tensptr, tensdelta);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x63cb
movq -0x10(%rbp), %rax
movl (%rax), %eax
cltd
idivl -0x14(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x63e6
movq -0x10(%rbp), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subl (%rcx), %eax
cltd
idivl -0x14(%rbp)
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edx
imull -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x6410
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/localtime.c
// Function: long_increment_overflow
static int
long_increment_overflow(lp, m)
long * const	lp;
int const	m;
{
	register long const	l = *lp;

	if ((l >= 0) ? (m > LONG_MAX - l) : (m < LONG_MIN - l))
		return TRUE;
	*lp += m;
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0x6446
movslq -0x14(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
subq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jg 0x645d
jmp 0x6466
movslq -0x14(%rbp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
subq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jge 0x6466
movl $0x1, -0x4(%rbp)
jmp 0x647b
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lyda[P]tz/localtime.c
// Function: tmcomp
static int
tmcomp(atmp, btmp)
register const struct tm * const atmp;
register const struct tm * const btmp;
{
	register int	result;

	if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
		(result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
		(result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&
		(result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
		(result = (atmp->tm_min - btmp->tm_min)) == 0)
			result = atmp->tm_sec - btmp->tm_sec;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x14(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x6509
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x10(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x6509
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x6509
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x6509
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x4(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x6509
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/test.c
// Function: main
int main(void)
{
	test_static_mutex();

	do_test(test_lock_unlock, 1);
	do_test(test_contention, 1);
	do_test(test_lock_cancellation, 1);
	do_test(test_trylock, 0);
	do_test(test_cond_wait, 1);
	do_test(test_cond_timedwait, 1);
	do_test(test_cond_wait_cancellation, 1);
	do_test(test_unlock_not_held, 0);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1e80
leaq 0x165(%rip), %rdi       # 0x1f60
movl $0x1, %esi
callq 0x1f20
leaq 0x1c4(%rip), %rdi       # 0x1fd0
movl $0x1, %esi
callq 0x1f20
leaq 0x3a3(%rip), %rdi       # 0x21c0
movl $0x1, %esi
callq 0x1f20
leaq 0x4d2(%rip), %rdi       # 0x2300
xorl %esi, %esi
callq 0x1f20
leaq 0x694(%rip), %rdi       # 0x24d0
movl $0x1, %esi
callq 0x1f20
leaq 0x823(%rip), %rdi       # 0x2670
movl $0x1, %esi
callq 0x1f20
leaq 0x982(%rip), %rdi       # 0x27e0
movl $0x1, %esi
callq 0x1f20
leaq 0xad1(%rip), %rdi       # 0x2940
xorl %esi, %esi
callq 0x1f20
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/test.c
// Function: do_test
static void do_test(void (*f)(skinny_mutex_t *m), int hammer)
{
	do_test_simple(f);
	do_test_cond_wait(f);
	if (hammer)
		do_test_hammer(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a60
movq -0x8(%rbp), %rdi
callq 0x2ae0
cmpl $0x0, -0xc(%rbp)
je 0x1f50
movq -0x8(%rbp), %rdi
callq 0x2d80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/test.c
// Function: test_contention
static void test_contention(skinny_mutex_t *mutex)
{
	struct test_contention tc;
	pthread_t threads[10];
	int i;

	tc.mutex = mutex;
	tc.held = 0;
	tc.count = 0;

	assert(!skinny_mutex_lock(tc.mutex));

	for (i = 0; i < 10; i++)
		assert(!pthread_create(&threads[i], NULL, bump, &tc));

	assert(!skinny_mutex_unlock(tc.mutex));

	for (i = 0; i < 10; i++)
		assert(!pthread_join(threads[i], NULL));

	assert(!skinny_mutex_lock(tc.mutex));
	assert(!tc.held);
	assert(tc.count == 10);
	assert(!skinny_mutex_unlock(tc.mutex));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2990
cmpl $0x0, %eax
jne 0x2005
jmp 0x2024
leaq 0x2608(%rip), %rdi      # 0x4614
leaq 0x2143(%rip), %rsi      # 0x4156
movl $0x3f, %edx
leaq 0x2612(%rip), %rcx      # 0x4631
callq 0x10b0
movl $0x0, -0x74(%rbp)
cmpl $0xa, -0x74(%rbp)
jge 0x2087
movslq -0x74(%rbp), %rax
leaq -0x70(%rbp), %rdi
shlq $0x3, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x10d5(%rip), %rdx      # 0x3120
leaq -0x18(%rbp), %rcx
callq 0x1130
cmpl $0x0, %eax
jne 0x205b
jmp 0x207a
leaq 0x25f6(%rip), %rdi      # 0x4658
leaq 0x20ed(%rip), %rsi      # 0x4156
movl $0x42, %edx
leaq 0x25bc(%rip), %rcx      # 0x4631
callq 0x10b0
jmp 0x207c
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x202b
movq -0x18(%rbp), %rdi
callq 0x29e0
cmpl $0x0, %eax
jne 0x2097
jmp 0x20b6
leaq 0x25e8(%rip), %rdi      # 0x4686
leaq 0x20b1(%rip), %rsi      # 0x4156
movl $0x44, %edx
leaq 0x2580(%rip), %rcx      # 0x4631
callq 0x10b0
movl $0x0, -0x74(%rbp)
cmpl $0xa, -0x74(%rbp)
jge 0x2108
movslq -0x74(%rbp), %rax
movq -0x70(%rbp,%rax,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1170
cmpl $0x0, %eax
jne 0x20dc
jmp 0x20fb
leaq 0x25c2(%rip), %rdi      # 0x46a5
leaq 0x206c(%rip), %rsi      # 0x4156
movl $0x47, %edx
leaq 0x253b(%rip), %rcx      # 0x4631
callq 0x10b0
jmp 0x20fd
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x20bd
movq -0x18(%rbp), %rdi
callq 0x2990
cmpl $0x0, %eax
jne 0x2118
jmp 0x2137
leaq 0x24f5(%rip), %rdi      # 0x4614
leaq 0x2030(%rip), %rsi      # 0x4156
movl $0x49, %edx
leaq 0x24ff(%rip), %rcx      # 0x4631
callq 0x10b0
cmpl $0x0, -0x10(%rbp)
jne 0x213f
jmp 0x215e
leaq 0x257f(%rip), %rdi      # 0x46c5
leaq 0x2009(%rip), %rsi      # 0x4156
movl $0x4a, %edx
leaq 0x24d8(%rip), %rcx      # 0x4631
callq 0x10b0
cmpl $0xa, -0xc(%rbp)
jne 0x2166
jmp 0x2185
leaq 0x2561(%rip), %rdi      # 0x46ce
leaq 0x1fe2(%rip), %rsi      # 0x4156
movl $0x4b, %edx
leaq 0x24b1(%rip), %rcx      # 0x4631
callq 0x10b0
movq -0x18(%rbp), %rdi
callq 0x29e0
cmpl $0x0, %eax
jne 0x2195
jmp 0x21b4
leaq 0x24ea(%rip), %rdi      # 0x4686
leaq 0x1fb3(%rip), %rsi      # 0x4156
movl $0x4c, %edx
leaq 0x2482(%rip), %rcx      # 0x4631
callq 0x10b0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/test.c
// Function: test_lock_cancellation
static void test_lock_cancellation(skinny_mutex_t *mutex)
{
	pthread_t thread;
	void *retval;

	assert(!skinny_mutex_lock(mutex));
	assert(!pthread_create(&thread, NULL, lock_cancellation_thread,
			       mutex));
	delay();
	assert(!pthread_cancel(thread));
	assert(!skinny_mutex_unlock(mutex));
	assert(!pthread_join(thread, &retval));
	assert(!retval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2990
cmpl $0x0, %eax
jne 0x21dc
jmp 0x21fb
leaq 0x23d3(%rip), %rdi      # 0x45b6
leaq 0x1f6c(%rip), %rsi      # 0x4156
movl $0x5d, %edx
leaq 0x2542(%rip), %rcx      # 0x4738
callq 0x10b0
movq -0x8(%rbp), %rcx
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xff2(%rip), %rdx       # 0x3200
callq 0x1130
cmpl $0x0, %eax
jne 0x221a
jmp 0x2239
leaq 0x2545(%rip), %rdi      # 0x4766
leaq 0x1f2e(%rip), %rsi      # 0x4156
movl $0x5f, %edx
leaq 0x2504(%rip), %rcx      # 0x4738
callq 0x10b0
callq 0x30c0
movq -0x10(%rbp), %rdi
callq 0x1190
cmpl $0x0, %eax
jne 0x224e
jmp 0x226d
leaq 0x2551(%rip), %rdi      # 0x47a6
leaq 0x1efa(%rip), %rsi      # 0x4156
movl $0x61, %edx
leaq 0x24d0(%rip), %rcx      # 0x4738
callq 0x10b0
movq -0x8(%rbp), %rdi
callq 0x29e0
cmpl $0x0, %eax
jne 0x227d
jmp 0x229c
leaq 0x2374(%rip), %rdi      # 0x45f8
leaq 0x1ecb(%rip), %rsi      # 0x4156
movl $0x62, %edx
leaq 0x24a1(%rip), %rcx      # 0x4738
callq 0x10b0
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1170
cmpl $0x0, %eax
jne 0x22b0
jmp 0x22cf
leaq 0x2507(%rip), %rdi      # 0x47be
leaq 0x1e98(%rip), %rsi      # 0x4156
movl $0x63, %edx
leaq 0x246e(%rip), %rcx      # 0x4738
callq 0x10b0
cmpq $0x0, -0x18(%rbp)
jne 0x22d8
jmp 0x22f7
leaq 0x24fe(%rip), %rdi      # 0x47dd
leaq 0x1e70(%rip), %rsi      # 0x4156
movl $0x64, %edx
leaq 0x2446(%rip), %rcx      # 0x4738
callq 0x10b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/test.c
// Function: test_trylock
static void test_trylock(skinny_mutex_t *mutex)
{
	pthread_t thread1, thread2;

	assert(!skinny_mutex_trylock(mutex));

	assert(!pthread_create(&thread1, NULL, trylock_thread, mutex));
	assert(!pthread_join(thread1, NULL));

	assert(!pthread_create(&thread1, NULL, trylock_contender_thread,
			       mutex));
	delay();
	assert(!pthread_create(&thread2, NULL, trylock_thread, mutex));
	assert(!pthread_join(thread2, NULL));
	assert(!skinny_mutex_unlock(mutex));
	assert(!pthread_join(thread1, NULL));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14f0
cmpl $0x0, %eax
jne 0x231c
jmp 0x233b
leaq 0x24e9(%rip), %rdi      # 0x480c
leaq 0x1e2c(%rip), %rsi      # 0x4156
movl $0x7c, %edx
leaq 0x24f3(%rip), %rcx      # 0x4829
callq 0x10b0
movq -0x8(%rbp), %rcx
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xf32(%rip), %rdx       # 0x3280
callq 0x1130
cmpl $0x0, %eax
jne 0x235a
jmp 0x2379
leaq 0x24ec(%rip), %rdi      # 0x484d
leaq 0x1dee(%rip), %rsi      # 0x4156
movl $0x7e, %edx
leaq 0x24b5(%rip), %rcx      # 0x4829
callq 0x10b0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1170
cmpl $0x0, %eax
jne 0x238d
jmp 0x23ac
leaq 0x24f0(%rip), %rdi      # 0x4884
leaq 0x1dbb(%rip), %rsi      # 0x4156
movl $0x7f, %edx
leaq 0x2482(%rip), %rcx      # 0x4829
callq 0x10b0
movq -0x8(%rbp), %rcx
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xf11(%rip), %rdx       # 0x32d0
callq 0x1130
cmpl $0x0, %eax
jne 0x23cb
jmp 0x23ea
leaq 0x24cf(%rip), %rdi      # 0x48a1
leaq 0x1d7d(%rip), %rsi      # 0x4156
movl $0x82, %edx
leaq 0x2444(%rip), %rcx      # 0x4829
callq 0x10b0
callq 0x30c0
movq -0x8(%rbp), %rcx
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xe7e(%rip), %rdx       # 0x3280
callq 0x1130
cmpl $0x0, %eax
jne 0x240e
jmp 0x242d
leaq 0x24cd(%rip), %rdi      # 0x48e2
leaq 0x1d3a(%rip), %rsi      # 0x4156
movl $0x84, %edx
leaq 0x2401(%rip), %rcx      # 0x4829
callq 0x10b0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1170
cmpl $0x0, %eax
jne 0x2441
jmp 0x2460
leaq 0x24d1(%rip), %rdi      # 0x4919
leaq 0x1d07(%rip), %rsi      # 0x4156
movl $0x85, %edx
leaq 0x23ce(%rip), %rcx      # 0x4829
callq 0x10b0
movq -0x8(%rbp), %rdi
callq 0x29e0
cmpl $0x0, %eax
jne 0x2470
jmp 0x248f
leaq 0x2181(%rip), %rdi      # 0x45f8
leaq 0x1cd8(%rip), %rsi      # 0x4156
movl $0x86, %edx
leaq 0x239f(%rip), %rcx      # 0x4829
callq 0x10b0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1170
cmpl $0x0, %eax
jne 0x24a3
jmp 0x24c2
leaq 0x23da(%rip), %rdi      # 0x4884
leaq 0x1ca5(%rip), %rsi      # 0x4156
movl $0x87, %edx
leaq 0x236c(%rip), %rcx      # 0x4829
callq 0x10b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/test.c
// Function: test_cond_wait
static void test_cond_wait(skinny_mutex_t *mutex)
{
	struct test_cond_wait tcw;
	pthread_t thread;

	tcw.mutex = mutex;
	assert(!pthread_cond_init(&tcw.cond, NULL));
	tcw.flag = 0;

	assert(!pthread_create(&thread, NULL, test_cond_wait_thread, &tcw));

	delay();
	assert(!skinny_mutex_lock(mutex));
	tcw.flag = 1;
	assert(!pthread_cond_signal(&tcw.cond));
	assert(!skinny_mutex_unlock(mutex));

	assert(!pthread_join(thread, NULL));

	assert(!pthread_cond_destroy(&tcw.cond));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10f0
cmpl $0x0, %eax
jne 0x24fc
jmp 0x251b
leaq 0x249c(%rip), %rdi      # 0x499f
leaq 0x1c4c(%rip), %rsi      # 0x4156
movl $0xaa, %edx
leaq 0x24ad(%rip), %rcx      # 0x49c3
callq 0x10b0
movl $0x0, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xe2f(%rip), %rdx       # 0x3360
leaq -0x48(%rbp), %rcx
callq 0x1130
cmpl $0x0, %eax
jne 0x2541
jmp 0x2560
leaq 0x24a1(%rip), %rdi      # 0x49e9
leaq 0x1c07(%rip), %rsi      # 0x4156
movl $0xad, %edx
leaq 0x2468(%rip), %rcx      # 0x49c3
callq 0x10b0
callq 0x30c0
movq -0x8(%rbp), %rdi
callq 0x2990
cmpl $0x0, %eax
jne 0x2575
jmp 0x2594
leaq 0x203a(%rip), %rdi      # 0x45b6
leaq 0x1bd3(%rip), %rsi      # 0x4156
movl $0xb0, %edx
leaq 0x2434(%rip), %rcx      # 0x49c3
callq 0x10b0
movl $0x1, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x10c0
cmpl $0x0, %eax
jne 0x25af
jmp 0x25ce
leaq 0x246f(%rip), %rdi      # 0x4a25
leaq 0x1b99(%rip), %rsi      # 0x4156
movl $0xb2, %edx
leaq 0x23fa(%rip), %rcx      # 0x49c3
callq 0x10b0
movq -0x8(%rbp), %rdi
callq 0x29e0
cmpl $0x0, %eax
jne 0x25de
jmp 0x25fd
leaq 0x2013(%rip), %rdi      # 0x45f8
leaq 0x1b6a(%rip), %rsi      # 0x4156
movl $0xb3, %edx
leaq 0x23cb(%rip), %rcx      # 0x49c3
callq 0x10b0
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1170
cmpl $0x0, %eax
jne 0x2611
jmp 0x2630
leaq 0x1d4b(%rip), %rdi      # 0x4363
leaq 0x1b37(%rip), %rsi      # 0x4156
movl $0xb5, %edx
leaq 0x2398(%rip), %rcx      # 0x49c3
callq 0x10b0
leaq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x1150
cmpl $0x0, %eax
jne 0x2644
jmp 0x2663
leaq 0x23fa(%rip), %rdi      # 0x4a45
leaq 0x1b04(%rip), %rsi      # 0x4156
movl $0xb7, %edx
leaq 0x2365(%rip), %rcx      # 0x49c3
callq 0x10b0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)