LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/wtarreau[P]httpterm/httpterm.c
// Function: buffer_slow_realign
void buffer_slow_realign(struct buffer *buf)
{
    char *end = buf->data + BUFSIZE;
    int off   = buf->data + BUFSIZE - buf->w;

    /* two possible cases :
     *   - the buffer is in one contiguous block, we move it in-place
     *   - the buffer is in two blocks, we move it via the trash
     */
    if (buf->l) {
	int block1 = buf->l;
	int block2 = 0;
	if (buf->r <= buf->w) {
	    /* non-contiguous block */
	    block1 = buf->data + BUFSIZE - buf->w;
	    block2 = buf->r - buf->data;
	}
	if (block2)
	    memcpy(trash, buf->data, block2);
	memmove(buf->data, buf->w, block1);
	if (block2)
	    memcpy(buf->data + block1, trash, block2);
    }

    /* adjust all known pointers */
    buf->w    = buf->data;
    buf->r   += off; if (buf->r   >= end) buf->r   -= BUFSIZE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
leaq 0x1000(%rax), %r13
movq 0x10(%rdi), %rsi
movq %r13, %rbp
subq %rsi, %rbp
movl (%rdi), %r12d
testl %r12d, %r12d
je 0x44fa
movq 0x8(%rbx), %rcx
cmpq %rsi, %rcx
cmovbel %ebp, %r12d
ja 0x44ef
subq %rax, %rcx
movl %ecx, %edx
testq %rdx, %rdx
je 0x44ef
movslq %ecx, %r14
leaq 0x28f76(%rip), %r15     # 0x2d430
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2250
movq 0x10(%rbx), %rsi
movq 0x30(%rbx), %rdi
movslq %r12d, %r12
movq %r12, %rdx
callq 0x2300
addq 0x30(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2250
jmp 0x44fa
movslq %r12d, %rdx
movq %rax, %rdi
callq 0x2300
movq 0x30(%rbx), %rax
movq %rax, 0x10(%rbx)
movslq %ebp, %rax
addq 0x8(%rbx), %rax
xorl %ecx, %ecx
cmpq %r13, %rax
setb %cl
shll $0xc, %ecx
addq %rcx, %rax
addq $-0x1000, %rax          # imm = 0xF000
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/wtarreau[P]httpterm/httpterm.c
// Function: fd_delete
static void fd_delete(int fd) {
    my_fd_clr(fd, StaticReadEvent);
    my_fd_clr(fd, StaticWriteEvent);
#if defined(ENABLE_EPOLL)
    if (PrevReadEvent) {
	my_fd_clr(fd, PrevReadEvent);
	my_fd_clr(fd, PrevWriteEvent);
    }
#endif

    close(fd);
    fdtab[fd].state = FD_STCLOSE;

    while ((maxfd-1 >= 0) && (fdtab[maxfd-1].state == FD_STCLOSE))
	    maxfd--;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
movl %ebx, %ecx
roll %cl, %eax
movq 0x7c85(%rip), %rcx      # 0xd3f8
movl %edi, %edx
sarl $0x5, %edx
movslq %edx, %rdx
andl %eax, (%rcx,%rdx,4)
movq 0x27c9b(%rip), %rcx     # 0x2d420
andl %eax, (%rcx,%rdx,4)
callq 0x21b0
movq 0x7bec(%rip), %rax      # 0xd380
movslq %ebx, %rcx
shlq $0x5, %rcx
movl $0x0, 0x18(%rax,%rcx)
movl 0x28ca3(%rip), %ecx     # 0x2e44c
testl %ecx, %ecx
jle 0x57cd
addq $-0x8, %rax
movl %ecx, %edx
shlq $0x5, %rdx
cmpl $0x0, (%rax,%rdx)
jne 0x57cd
leal -0x1(%rcx), %edx
movl %edx, 0x28c86(%rip)     # 0x2e44c
cmpl $0x1, %ecx
movl %edx, %ecx
jg 0x57b1
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wtarreau[P]httpterm/httpterm.c
// Function: tv_cmp2_ms
static int tv_cmp2_ms(struct timeval *tv1, struct timeval *tv2) {
    if (tv_iseternity(tv1))
	if (tv_iseternity(tv2))
	    return 0; /* same */
	else
	    return 1; /* tv1 later than tv2 */
    else if (tv_iseternity(tv2))
	return -1; /* tv2 later than tv1 */
    
    if (tv1->tv_sec == tv2->tv_sec) {
	if (tv1->tv_usec >= tv2->tv_usec + 1000)
	    return 1;
	else if (tv2->tv_usec >= tv1->tv_usec + 1000)
	    return -1;
	else
	    return 0;
    }
    else if ((tv1->tv_sec > tv2->tv_sec + 1) ||
	     ((tv1->tv_sec == tv2->tv_sec + 1) && (tv1->tv_usec + 1000000 >= tv2->tv_usec + 1000)))
	return 1;
    else if ((tv2->tv_sec > tv1->tv_sec + 1) ||
	     ((tv2->tv_sec == tv1->tv_sec + 1) && (tv2->tv_usec + 1000000 >= tv1->tv_usec + 1000)))
	return -1;
    else
	return 0;
}

// Assembly:
movq (%rdi), %rdx
testq %rdx, %rdx
jne 0x57e2
cmpq $0x0, 0x8(%rdi)
je 0x5868
movq 0x7c17(%rip), %rsi      # 0xd400
movq 0x7c18(%rip), %rcx      # 0xd408
movq %rsi, %rax
orq %rcx, %rax
jne 0x57fe
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
cmpq %rsi, %rdx
jne 0x582a
movq 0x8(%rdi), %rdx
leaq 0x3e8(%rcx), %rsi
movl $0x1, %eax
cmpq %rsi, %rdx
jge 0x5867
addq $0x3e8, %rdx            # imm = 0x3E8
xorl %eax, %eax
cmpq %rdx, %rcx
setge %al
negl %eax
retq
leaq 0x1(%rsi), %r8
movl $0x1, %eax
cmpq %r8, %rdx
jg 0x5867
jne 0x5849
movl $0xf3e58, %r8d          # imm = 0xF3E58
addq 0x8(%rdi), %r8
cmpq %rcx, %r8
jge 0x5867
incq %rdx
cmpq %rdx, %rsi
jg 0x57f8
jne 0x5865
addq $0xf3e58, %rcx          # imm = 0xF3E58
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq 0x8(%rdi), %rcx
jge 0x5867
xorl %eax, %eax
retq
movq 0x7b99(%rip), %rcx      # 0xd408
xorl %eax, %eax
orq 0x7b88(%rip), %rcx      # 0xd400
setne %al
retq
// File: /workspace/github_c_makefile_star2_O3/wtarreau[P]httpterm/httpterm.c
// Function: tv_cmp_ms
static int tv_cmp_ms(struct timeval *tv1, struct timeval *tv2) {
    if (tv1->tv_sec == tv2->tv_sec) {
	if (tv2->tv_usec >= tv1->tv_usec + 1000)
	    return -1;
	else if (tv1->tv_usec >= tv2->tv_usec + 1000)
	    return 1;
	else
	    return 0;
    }
    else if ((tv2->tv_sec > tv1->tv_sec + 1) ||
	     ((tv2->tv_sec == tv1->tv_sec + 1) && (tv2->tv_usec + 1000000 >= tv1->tv_usec + 1000)))
	return -1;
    else if ((tv1->tv_sec > tv2->tv_sec + 1) ||
	     ((tv1->tv_sec == tv2->tv_sec + 1) && (tv1->tv_usec + 1000000 >= tv2->tv_usec + 1000)))
	return 1;
    else
	return 0;
}

// Assembly:
movq (%rdi), %rcx
movq (%rsi), %rdx
cmpq %rdx, %rcx
jne 0x6095
movq 0x8(%rsi), %rcx
movq 0x8(%rdi), %rdx
leaq 0x3e8(%rdx), %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rsi, %rcx
jge 0x60d5
addq $0x3e8, %rcx            # imm = 0x3E8
xorl %eax, %eax
cmpq %rcx, %rdx
setge %al
retq
leaq 0x1(%rcx), %r8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r8, %rdx
jg 0x60d5
jne 0x60b5
movl $0xf3e58, %r8d          # imm = 0xF3E58
addq 0x8(%rsi), %r8
cmpq 0x8(%rdi), %r8
jge 0x60d5
incq %rdx
movl $0x1, %eax
cmpq %rdx, %rcx
jg 0x60d5
jne 0x60d3
movl $0xf3e58, %ecx          # imm = 0xF3E58
addq 0x8(%rdi), %rcx
cmpq 0x8(%rsi), %rcx
jge 0x60d5
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/wtarreau[P]httpterm/httpterm.c
// Function: sig_dump_state
void sig_dump_state(int sig) {
    struct proxy *p = proxy;

    Warning("SIGHUP received, dumping servers states.\n");
    while (p) {
	struct server *s = p->srv;

	while (s) {
	    snprintf(trash, sizeof(trash),
		     "SIGHUP: Server %s/%s : Conn: %d act, %d pend, %d tot.",
		     p->id, s->id,
		     s->cur_sess, 0, s->cum_sess);
	    Warning("%s\n", trash);
	    s = s->next;
	}

	snprintf(trash, sizeof(trash),
		 "SIGHUP: Proxy %s has %d active servers available."
		 " Conn: %d act, %d pend (%d unass), %d tot.",
		 p->id, p->srv_act, 
		 p->nbconn, 0, 0, p->cum_conn);
	Warning("%s\n", trash);
	p = p->next;
    }
    signal(sig, sig_dump_state);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, 0x4(%rsp)
movq 0x6fe0(%rip), %rbp      # 0xd378
leaq 0x4081(%rip), %rdi      # 0xa420
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2b2f
testq %rbp, %rbp
je 0x6457
leaq 0x27078(%rip), %r14     # 0x2d430
leaq 0x4999(%rip), %r12      # 0xad58
leaq 0x4084(%rip), %r13      # 0xa44a
movq 0x10(%rbp), %r15
testq %r15, %r15
je 0x640b
movq 0x38(%rbp), %rcx
movq 0x8(%r15), %r8
movl 0x18(%r15), %r9d
movl 0x1c(%r15), %r10d
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
movq %r13, %rdx
xorl %eax, %eax
pushq %r10
pushq $0x0
callq 0x2170
addq $0x10, %rsp
movq %r12, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2b2f
movq (%r15), %r15
jmp 0x63ca
movq 0x38(%rbp), %rcx
movl 0x18(%rbp), %r8d
movl 0x40(%rbp), %r9d
movl 0x44(%rbp), %r10d
subq $0x8, %rsp
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
leaq 0x4052(%rip), %rdx      # 0xa480
xorl %eax, %eax
pushq %r10
pushq %rbx
pushq %rbx
callq 0x2170
addq $0x20, %rsp
movq %r12, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2b2f
movq 0x50(%rbp), %rbp
testq %rbp, %rbp
jne 0x63c6
leaq -0xdc(%rip), %rsi       # 0x6382
movl 0x4(%rsp), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2210
// File: /workspace/github_c_makefile_star2_O3/wtarreau[P]httpterm/httpterm.c
// Function: init_default_instance
void init_default_instance() {
    memset(&defproxy, 0, sizeof(defproxy));
    defproxy.state = PR_STNEW;
    defproxy.maxconn = cfg_maxconn ? cfg_maxconn : global.maxconn;
    if (!defproxy.maxconn)
	defproxy.maxconn = DEFAULT_MAXPCONN;
}

// Assembly:
pushq %rax
leaq 0x27c48(%rip), %rdi     # 0x2e450
movl $0xe0, %edx
xorl %esi, %esi
callq 0x21a0
movl 0x6b16(%rip), %eax      # 0xd330
testl %eax, %eax
jne 0x6824
movl 0x6b84(%rip), %eax      # 0xd3a8
testl %eax, %eax
movl $0x40000000, %ecx       # imm = 0x40000000
cmovnel %eax, %ecx
movl %ecx, 0x27c64(%rip)     # 0x2e498
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/wtarreau[P]httpterm/httpterm.c
// Function: pool_destroy
void pool_destroy(void **pool)
{
    void *temp, *next;
    next = pool;
    while (next) {
	temp = next;
	next = *(void **)temp;
	free(temp);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x848b
pushq %rbx
movq (%rdi), %rbx
callq 0x2050
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x847a
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/wtarreau[P]httpterm/httpterm.c
// Function: deinit
void deinit(void) {
    struct proxy *p = proxy;
    struct server *s,*s_next;
    struct listener *l,*l_next;
  
    while (p) {
	if (p->id)
	    free(p->id);

	/* only strup if the user have set in config.
	   When should we free it?!
	   if (p->errmsg.msg400) free(p->errmsg.msg400);
	   if (p->errmsg.msg403) free(p->errmsg.msg403);
	   if (p->errmsg.msg408) free(p->errmsg.msg408);
	   if (p->errmsg.msg500) free(p->errmsg.msg500);
	   if (p->errmsg.msg502) free(p->errmsg.msg502);
	   if (p->errmsg.msg503) free(p->errmsg.msg503);
	   if (p->errmsg.msg504) free(p->errmsg.msg504);
	*/

	s = p->srv;
	while (s) {
	    s_next = s->next;
	    if (s->id)
		free(s->id);
	    
	    free(s);
	    s = s_next;
	}/* end while(s) */
	
	l = p->listen;
	while (l) {
	    l_next = l->next;
	    free(l);
	    l = l_next;
	}/* end while(l) */
	
	p = p->next;
    }/* end while(p) */
    
    if (global.chroot)    free(global.chroot);
    if (global.pidfile)   free(global.pidfile);
    
    if (StaticReadEvent)  free(StaticReadEvent);
    if (StaticWriteEvent) free(StaticWriteEvent);
    if (fdtab)            free(fdtab);
    
    pool_destroy(pool_session);
    pool_destroy(pool_buffer);
    pool_destroy(pool_fdtab);
    pool_destroy(pool_task);
    
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x4ee0(%rip), %r14      # 0xd378
testq %r14, %r14
je 0x84f7
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x84ab
callq 0x2050
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0x84d5
movq (%rbx), %r15
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x84c5
callq 0x2050
movq %rbx, %rdi
callq 0x2050
movq %r15, %rbx
testq %r15, %r15
jne 0x84b4
movq (%r14), %rdi
testq %rdi, %rdi
je 0x84f1
movq 0x88(%rdi), %rbx
callq 0x2050
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x84dd
movq 0x50(%r14), %r14
jmp 0x8498
movq 0x4ed2(%rip), %rdi      # 0xd3d0
testq %rdi, %rdi
je 0x8508
callq 0x2050
movq 0x4ec9(%rip), %rdi      # 0xd3d8
testq %rdi, %rdi
je 0x8519
callq 0x2050
movq 0x4ed8(%rip), %rdi      # 0xd3f8
testq %rdi, %rdi
je 0x852a
callq 0x2050
movq 0x24eef(%rip), %rdi     # 0x2d420
testq %rdi, %rdi
je 0x853b
callq 0x2050
movq 0x4e3e(%rip), %rdi      # 0xd380
testq %rdi, %rdi
je 0x854c
callq 0x2050
movq 0x4e05(%rip), %rdi      # 0xd358
testq %rdi, %rdi
je 0x8568
movq (%rdi), %rbx
callq 0x2050
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x8558
movq 0x4df1(%rip), %rdi      # 0xd360
testq %rdi, %rdi
je 0x8584
movq (%rdi), %rbx
callq 0x2050
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x8574
movq 0x4ddd(%rip), %rdi      # 0xd368
testq %rdi, %rdi
je 0x85a0
movq (%rdi), %rbx
callq 0x2050
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x8590
movq 0x4dc9(%rip), %rdi      # 0xd370
testq %rdi, %rdi
je 0x85bc
movq (%rdi), %rbx
callq 0x2050
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x85ac
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/codeniko[P]CS214-Malloc-Free/Test8.c
// Function: main
void main()
{
    void* p = malloc(2);
    free(p);
    printf("p has been freed\n");
    free(p + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xeaa(%rip), %rbx       # 0x2004
movl $0x2, %edi
movq %rbx, %rsi
movl $0x6, %edx
callq 0x11a4
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movl $0x7, %edx
callq 0x12fd
leaq 0xe86(%rip), %rdi       # 0x200c
callq 0x1030
incq %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x9, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x12fd
nop
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aes256otrsv2/ref/OTR.c
// Function: Setup
int Setup(const uint8 *skey)
{
	uint8 cst[16] = {0};

	KeySchedule(KeyLen, ENC, skey);
	Encryption(KeyLen, cst, gamma);
	mul2(gamma, gamma2); 
	mul2(gamma2, Q); /* Q = 4gamma */
	return SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rdx
vxorps %xmm0, %xmm0, %xmm0
movq %rsp, %rbx
vmovaps %xmm0, (%rbx)
movl $0x100, %edi            # imm = 0x100
xorl %esi, %esi
callq 0x1090
movq 0x3d64(%rip), %r14      # 0x4f88
movl $0x100, %edi            # imm = 0x100
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1100
movzbl (%r14), %eax
vmovd %eax, %xmm0
vpbroadcastb %xmm0, %xmm0
movw $0x7fff, %cx            # imm = 0x7FFF
kmovd %ecx, %k1
vmovdqu8 0x1(%r14), %xmm1 {%k1} {z}
vpalignr $0xf, %xmm0, %xmm1, %xmm0 # xmm0 = xmm0[15],xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
vpsrlw $0x7, %xmm1, %xmm1
vpbroadcastd 0x1d99(%rip), %xmm2 # 0x3000
vpaddw %xmm0, %xmm0, %xmm0
vpternlogd $0xe2, %xmm1, %xmm2, %xmm0
movq 0x3d77(%rip), %rcx      # 0x4ff0
vmovdqu8 %xmm0, (%rcx) {%k1}
shrl $0x7, %eax
movb 0xf(%r14), %dl
addb %dl, %dl
leaq 0x1d91(%rip), %rsi      # 0x3020
xorb (%rax,%rsi), %dl
movb %dl, 0xf(%rcx)
movzbl (%rcx), %eax
vmovd %eax, %xmm0
vpbroadcastb %xmm0, %xmm0
vmovdqu8 0x1(%rcx), %xmm1 {%k1} {z}
vpalignr $0xf, %xmm0, %xmm1, %xmm0 # xmm0 = xmm0[15],xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
vpsrlw $0x7, %xmm1, %xmm1
vpaddw %xmm0, %xmm0, %xmm0
vpternlogd $0xe2, %xmm1, %xmm2, %xmm0
movq 0x3cf0(%rip), %rcx      # 0x4fb8
vmovdqu8 %xmm0, (%rcx) {%k1}
shrl $0x7, %eax
addb %dl, %dl
xorb (%rax,%rsi), %dl
movb %dl, 0xf(%rcx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aes256otrsv2/ref/OTR.c
// Function: nEnc
int nEnc(const uint8 *nonce, uint32 nonce_len, uint32 t_len){
	uint8 tmp[BLOCK]={0};

	memcpy(&tmp[BLOCK-nonce_len],nonce,nonce_len);
	tmp[0]=(uint8)((t_len*8)%(BLOCK*8)<<1);
	tmp[BLOCK-nonce_len-1] |= 0x01;
#ifdef INTERMEDIATE
	printf("(Format(tau,N)||0*||1||N) :\n"); printbseq(tmp,BLOCK);
#endif
	Encryption(KeyLen, tmp, delta);	// delta = E(Format(tau,N))
	if(ADP==Seri){
		xor(delta, TA, delta); // delta ^= TA
	}
	mul2(delta, L);
	mul2(L, L); //L = 4delta
	return SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %rsi
vxorps %xmm0, %xmm0, %xmm0
movq %rsp, %r14
vmovaps %xmm0, (%r14)
movl $0x10, %eax
subl %ebp, %eax
leaq (%rsp,%rax), %rdi
movl %ebp, %edx
callq 0x1110
shlb $0x4, %bl
movb %bl, (%r14)
movl $0xf, %eax
subl %ebp, %eax
orb $0x1, (%rsp,%rax)
movq 0x3ca0(%rip), %rbx      # 0x4fc8
movl $0x100, %edi            # imm = 0x100
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1100
movq 0x3ca9(%rip), %rax      # 0x4fe8
vmovaps (%rax), %xmm0
vxorps (%rbx), %xmm0, %xmm0
vmovaps %xmm0, (%rbx)
movzbl (%rbx), %eax
vmovd %eax, %xmm0
vpbroadcastb %xmm0, %xmm0
movw $0x7fff, %cx            # imm = 0x7FFF
kmovd %ecx, %k1
vmovdqu8 0x1(%rbx), %xmm1 {%k1} {z}
vpalignr $0xf, %xmm0, %xmm1, %xmm0 # xmm0 = xmm0[15],xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
vpsrlw $0x7, %xmm1, %xmm1
vpbroadcastd 0x1c83(%rip), %xmm2 # 0x3000
vpaddw %xmm0, %xmm0, %xmm0
vpternlogd $0xe2, %xmm1, %xmm2, %xmm0
movq 0x3c09(%rip), %rcx      # 0x4f98
vmovdqu8 %xmm0, (%rcx) {%k1}
shrl $0x7, %eax
movb 0xf(%rbx), %dl
addb %dl, %dl
leaq 0x1c7c(%rip), %rsi      # 0x3020
xorb (%rax,%rsi), %dl
movb %dl, 0xf(%rcx)
movzbl (%rcx), %eax
vmovd %eax, %xmm0
vpbroadcastb %xmm0, %xmm0
vmovdqu8 0x1(%rcx), %xmm1 {%k1} {z}
vpalignr $0xf, %xmm0, %xmm1, %xmm0 # xmm0 = xmm0[15],xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
vpsrlw $0x7, %xmm1, %xmm1
vpaddw %xmm0, %xmm0, %xmm0
vpternlogd $0xe2, %xmm1, %xmm2, %xmm0
vmovdqu8 %xmm0, (%rcx) {%k1}
shrl $0x7, %eax
movb 0xf(%rcx), %dl
addb %dl, %dl
xorb (%rax,%rsi), %dl
movb %dl, 0xf(%rcx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aes256otrsv2/ref/OTR.c
// Function: AFunc
int AFunc(
		  const uint8 *header,
		  uint32 h_len)
{
	uint32 i,j = 0;
	uint32 m, last;
	uint8 ASum[BLOCK]={0}, tmp[BLOCK], mask[BLOCK];

	last = h_len % BLOCK;
	if(last == 0) last = BLOCK;
	m = (h_len-last) / BLOCK; //header = m blocks + last bytes

	memcpy(mask,Q,BLOCK);
	/* XE */
	for(i = 0; i < m; i++, j=j+BLOCK){
		xor(mask,header+j,tmp);
		Encryption(KeyLen,tmp,tmp);
		xor(ASum,tmp,ASum);
		mul2(mask,mask);
	}
	/* last block */
	ozp(last,header+j,tmp);
	xor(ASum,tmp,ASum);

	if(last != BLOCK ){
		xor(mask, gamma, mask);
	}
	else{
		xor(mask,gamma2,mask);
	}
	xor(ASum,mask,ASum);
	Encryption(KeyLen,ASum,TA);
    return SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %rbx
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x40(%rsp)
movl %esi, %r15d
andl $0xf, %r15d
movl $0x10, %ecx
cmovnel %r15d, %ecx
subl %ecx, %ebp
movq 0x332f(%rip), %rax      # 0x4fb8
vmovdqa (%rax), %xmm0
vmovdqa %xmm0, 0x10(%rsp)
cmpl $0x10, %ebp
jae 0x1ca0
xorl %r13d, %r13d
jmp 0x1d69
movl %ecx, 0x28(%rsp)
movl %r15d, 0x2c(%rsp)
shrl $0x4, %ebp
leaq 0x11(%rsp), %r12
xorl %r13d, %r13d
leaq 0x30(%rsp), %r14
movw $0x7fff, %ax            # imm = 0x7FFF
kmovd %eax, %k1
kmovw %k1, 0xe(%rsp)
leaq 0x1352(%rip), %r15      # 0x3020
vmovups (%rbx,%r13), %xmm0
vxorps 0x10(%rsp), %xmm0, %xmm0
vmovaps %xmm0, 0x30(%rsp)
movl $0x100, %edi            # imm = 0x100
movq %r14, %rsi
movq %r14, %rdx
callq 0x1100
vmovaps 0x30(%rsp), %xmm0
vxorps 0x40(%rsp), %xmm0, %xmm0
vmovaps %xmm0, 0x40(%rsp)
movzbl 0x10(%rsp), %eax
vmovd %eax, %xmm0
vpbroadcastb %xmm0, %xmm0
kmovw 0xe(%rsp), %k1
vmovdqu8 (%r12), %xmm1 {%k1} {z}
vpalignr $0xf, %xmm0, %xmm1, %xmm0 # xmm0 = xmm0[15],xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
vpsrlw $0x7, %xmm1, %xmm1
vpaddw %xmm0, %xmm0, %xmm0
vpternlogd $0xe4, 0x12c9(%rip){1to4}, %xmm1, %xmm0 # 0x3000
vmovdqu8 %xmm0, 0x10(%rsp) {%k1}
shrl $0x7, %eax
movb 0x1f(%rsp), %cl
addb %cl, %cl
xorb (%rax,%r15), %cl
movb %cl, 0x1f(%rsp)
addq $0x10, %r13
decl %ebp
jne 0x1cce
andl $-0x10, %r13d
movl 0x2c(%rsp), %r15d
movl 0x28(%rsp), %ecx
addq %r13, %rbx
movl %ecx, %r14d
movl $0x10, %eax
subq %r14, %rax
xorl %edx, %edx
testl %r15d, %r15d
cmovneq %rax, %rdx
leaq (%rsp,%r14), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x1030
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1110
testl %r15d, %r15d
je 0x1daa
movb $-0x80, 0x30(%rsp,%r14)
vmovaps 0x30(%rsp), %xmm0
vxorps 0x40(%rsp), %xmm0, %xmm0
vmovaps %xmm0, 0x40(%rsp)
testl %r15d, %r15d
jne 0x1dca
movq 0x3228(%rip), %rax      # 0x4ff0
jmp 0x1dd1
movq 0x31b7(%rip), %rax      # 0x4f88
vmovaps (%rax), %xmm1
vxorps 0x10(%rsp), %xmm1, %xmm1
vmovaps %xmm1, 0x10(%rsp)
vxorps %xmm0, %xmm1, %xmm0
leaq 0x40(%rsp), %rsi
vmovaps %xmm0, (%rsi)
movq 0x31f3(%rip), %rdx      # 0x4fe8
movl $0x100, %edi            # imm = 0x100
callq 0x1100
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aes256otrsv2/ref/OTR.c
// Function: AFuncS
int AFuncS(
		  const uint8 *header,
		  uint32 h_len)
{
	uint32 i,j = 0;
	uint32 m, last;
	uint8 tmp[BLOCK], chain[BLOCK]={0};

	last = h_len % BLOCK;
	if(last == 0) last = BLOCK;
	m = (h_len-last) / BLOCK; //header = m blocks + last bytes

	/* CBC */
	for(i = 0; i < m; i++, j=j+BLOCK){
		xor(chain,header+j,chain);
		Encryption(KeyLen,chain,chain);
	}
	/* last block */
	ozp(last,header+j,tmp);
	xor(tmp,chain,chain);
	if(last != BLOCK ){
		xor(chain,gamma2,chain);
	}
	else{
		xor(chain,Q,chain);
	}
	Encryption(KeyLen,chain,TA);
    return SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r15d
andl $0xf, %r15d
movl $0x10, %r12d
cmovnel %r15d, %r12d
subl %r12d, %ebp
cmpl $0x10, %ebp
jae 0x1e4a
xorl %r13d, %r13d
jmp 0x1e7f
shrl $0x4, %ebp
xorl %r13d, %r13d
movq %rsp, %r14
vmovups (%rbx,%r13), %xmm0
vxorps (%rsp), %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
movl $0x100, %edi            # imm = 0x100
movq %r14, %rsi
movq %r14, %rdx
callq 0x1100
addq $0x10, %r13
decl %ebp
jne 0x1e53
andl $-0x10, %r13d
addq %r13, %rbx
movl %r12d, %r14d
movl $0x10, %eax
subq %r14, %rax
xorl %edx, %edx
testl %r15d, %r15d
cmovneq %rax, %rdx
leaq (%rsp,%r14), %rdi
addq $0x10, %rdi
xorl %esi, %esi
callq 0x1030
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1110
testl %r15d, %r15d
je 0x1ec0
movb $-0x80, 0x10(%rsp,%r14)
vmovaps (%rsp), %xmm0
vxorps 0x10(%rsp), %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
testl %r15d, %r15d
jne 0x1ede
movq 0x30dc(%rip), %rax      # 0x4fb8
jmp 0x1ee5
movq 0x310b(%rip), %rax      # 0x4ff0
vxorps (%rax), %xmm0, %xmm0
movq %rsp, %rsi
vmovaps %xmm0, (%rsi)
movq 0x30f1(%rip), %rdx      # 0x4fe8
movl $0x100, %edi            # imm = 0x100
callq 0x1100
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/motet-a[P]libforks/tests/closed_exit_pipe.c
// Function: main
int main() {
  libforks_ServerConn conn;

  check(libforks_start(&conn) == libforks_OK);

  int exit_fd;
  pid_t child_pid;
  int socket_fd;

  libforks_Result r = libforks_fork(
    conn,
    &child_pid, // pid_ptr
    &socket_fd, // socket_fd_ptr
    &exit_fd, // exit_fd_ptr
    child_main
  );
  check(r == libforks_OK);

  close(exit_fd);
  write(socket_fd, "o", 1);
  check(write(socket_fd, "o", 1) == 1);

  // child exits now, but since exit_fd is closed we have to do this
  // dirty hack
  check(libforks_eval(conn, serv_wait) == libforks_OK);

  check(libforks_stop(conn) == libforks_OK);

  return 0;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x10(%rsp), %rdi
callq 0x17fb
testl %eax, %eax
jne 0x13ba
movq 0x10(%rsp), %rdi
leaq 0xfb(%rip), %r8         # 0x143a
leaq 0x1c(%rsp), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x2188
testl %eax, %eax
jne 0x13cb
movl 0x18(%rsp), %edi
callq 0x10c0
movl 0xc(%rsp), %edi
leaq 0x1ce8(%rip), %rbx      # 0x3053
movl $0x1, %edx
movq %rbx, %rsi
callq 0x1080
movl 0xc(%rsp), %edi
movl $0x1, %edx
movq %rbx, %rsi
callq 0x1080
cmpq $0x1, %rax
jne 0x13dc
movq 0x10(%rsp), %rdi
leaq 0xe2(%rip), %rsi        # 0x147d
callq 0x2404
testl %eax, %eax
jne 0x13ed
movq 0x10(%rsp), %rdi
callq 0x2343
testl %eax, %eax
jne 0x13fe
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
leaq 0x1c43(%rip), %rdi      # 0x3004
movl $0x12, %esi
callq 0x140f
leaq 0x1c70(%rip), %rdi      # 0x3042
movl $0x1f, %esi
callq 0x140f
leaq 0x1c72(%rip), %rdi      # 0x3055
movl $0x23, %esi
callq 0x140f
leaq 0x1c7f(%rip), %rdi      # 0x3073
movl $0x27, %esi
callq 0x140f
leaq 0x1c9c(%rip), %rdi      # 0x30a1
movl $0x29, %esi
callq 0x140f
// File: /workspace/github_c_makefile_star2_O3/motet-a[P]libforks/libforks.c
// Function: libforks_fork
libforks_Result libforks_fork(
    libforks_ServerConn conn_p,
    pid_t *pid_ptr, // out
    int *socket_fd_ptr, // out
    int *exit_fd_ptr, // out
    void (*entrypoint)(libforks_ServerConn conn, int socket_fd)
  ) {

  ServerConn *conn = conn_p.private;

  ClientMessage req = {
    .type = ClientMessageType_FORK_REQUEST,
    .u = {
      .fork_request = {
        .create_user_socket = socket_fd_ptr != NULL,
        .create_exit_pipe = exit_fd_ptr != NULL,
        .entrypoint = entrypoint,
      },
    },
  };

  if (write_exact(conn->socket, &req, sizeof req) == -1) {
    return libforks_WRITE_ERROR;
  }

  ServerMessage res;
  int received_fds[2] = {-1, -1};
  int read_res = libforks_read_socket_fds(
    conn->socket,
    &res, sizeof res,
    received_fds, 2
  );
  if (read_res == -1) {
    return libforks_READ_ERROR;
  }

  if (res.type == ServerMessageType_FORK_FAILURE) {
    assert(res.u.fork_failure.error_code != libforks_OK);
    errno = res.u.fork_failure.saved_errno;
    return res.u.fork_failure.error_code;
  }

  assert(res.type == ServerMessageType_FORK_SUCCESS);

  if (pid_ptr) {
    *pid_ptr = res.u.fork_success.pid;
  }

  unsigned i = 0;
  if (socket_fd_ptr) {
    *socket_fd_ptr = received_fds[i++];
  }
  if (exit_fd_ptr) {
    *exit_fd_ptr = received_fds[i++];
  }

  return libforks_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
testq %rdx, %rdx
leaq 0x18(%rsp), %rsi
setne (%rsi)
testq %rcx, %rcx
setne 0x1(%rsi)
movq %rdi, %r13
movq %r8, 0x8(%rsi)
movl $0x0, 0x10(%rsi)
movl 0x4(%rdi), %edi
movl $0x18, %edx
callq 0x17cb
cmpl $-0x1, %eax
je 0x2223
leaq 0x10(%rsp), %r12
movq $-0x1, (%r12)
movl 0x4(%r13), %edi
leaq 0x4(%rsp), %rsi
movl $0xc, %edx
movl $0x2, %r8d
movq %r12, %rcx
callq 0x148c
cmpl $-0x1, %eax
je 0x222a
movl 0xc(%rsp), %eax
testl %eax, %eax
je 0x2231
cmpl $0x1, %eax
jne 0x226a
cmpl $0x0, 0x4(%rsp)
je 0x2289
movl 0x8(%rsp), %ebx
callq 0x1050
movl %ebx, (%rax)
movl 0x4(%rsp), %eax
jmp 0x225c
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x225c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x225c
testq %r15, %r15
je 0x223d
movl 0x4(%rsp), %eax
movl %eax, (%r15)
testq %r14, %r14
je 0x224f
leaq 0x14(%rsp), %r12
movl -0x4(%r12), %eax
movl %eax, (%r14)
xorl %eax, %eax
testq %rbx, %rbx
je 0x225c
movl (%r12), %ecx
movl %ecx, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1059(%rip), %rdi      # 0x32ca
leaq 0xf17(%rip), %rsi       # 0x318f
leaq 0xfdd(%rip), %rcx       # 0x325c
movl $0x43f, %edx            # imm = 0x43F
callq 0x10b0
leaq 0xf9f(%rip), %rdi       # 0x322f
leaq 0xef8(%rip), %rsi       # 0x318f
leaq 0xfbe(%rip), %rcx       # 0x325c
movl $0x43a, %edx            # imm = 0x43A
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/motet-a[P]libforks/libforks.c
// Function: finalize_stop
static libforks_Result finalize_stop(ServerConn *conn) {
  int status;
  if (waitpid(conn->server_pid, &status, 0) == -1) {
    return libforks_WAIT_ERROR;
  }

  assert(WIFEXITED(status) || WIFSIGNALED(status));

  close(conn->socket); // ignore error
  free(conn);
  return libforks_OK;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %edi
leaq 0xc(%rsp), %rsi
xorl %edx, %edx
callq 0x1190
cmpl $-0x1, %eax
je 0x2319
movl 0xc(%rsp), %eax
andl $0x7f, %eax
je 0x2305
shll $0x18, %eax
addl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x1ffffff, %eax        # imm = 0x1FFFFFF
jle 0x2324
movl 0x4(%rbx), %edi
callq 0x18ef
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
jmp 0x231e
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
addq $0x10, %rsp
popq %rbx
retq
leaq 0x12ec(%rip), %rdi      # 0x3617
leaq 0xe5d(%rip), %rsi       # 0x318f
leaq 0x1436(%rip), %rcx      # 0x376f
movl $0x457, %edx            # imm = 0x457
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/motet-a[P]libforks/libforks.c
// Function: libforks_kill_all
libforks_Result libforks_kill_all(libforks_ServerConn conn_p, int signal) {
  ServerConn *conn = conn_p.private;

  ClientMessage req = {
    .type = ClientMessageType_KILL_ALL_REQUEST,
    .u = {
      .kill_all_request = {
        .signal = signal
      },
    },
  };
  if (write_exact(conn->socket, &req, sizeof req) == -1) {
    return libforks_WRITE_ERROR;
  }

  ServerMessage res;
  if (read_exact(conn->socket, &res, sizeof res) == -1) {
    return libforks_READ_ERROR;
  }

  assert(res.type == ServerMessageType_KILL_SUCCESS);
  return libforks_OK;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movl %esi, (%rax)
movl $0x3, 0x10(%rax)
movl 0x4(%rdi), %edi
movl $0x18, %edx
movq %rax, %rsi
callq 0x17cb
cmpl $-0x1, %eax
je 0x23f2
movl 0x4(%rbx), %edi
leaq 0xc(%rsp), %rsi
movl $0xc, %edx
callq 0x163f
cmpl $-0x1, %eax
je 0x23f9
xorl %eax, %eax
cmpl $0x2, 0x14(%rsp)
je 0x23fe
leaq 0xf1b(%rip), %rdi       # 0x32f5
leaq 0xdae(%rip), %rsi       # 0x318f
leaq 0xf38(%rip), %rcx       # 0x3320
movl $0x494, %edx            # imm = 0x494
callq 0x10b0
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x23fe
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/motet-a[P]libforks/libforks.c
// Function: libforks_eval
libforks_Result libforks_eval(libforks_ServerConn conn_p, void (*function)(void)) {
  ServerConn *conn = conn_p.private;

  ClientMessage req = {
    .type = ClientMessageType_EVAL_REQUEST,
    .u = {
      .eval_request = {
        .function = function
      },
    },
  };
  if (write_exact(conn->socket, &req, sizeof req) == -1) {
    return libforks_WRITE_ERROR;
  }

  ServerMessage res;
  if (read_exact(conn->socket, &res, sizeof res) == -1) {
    return libforks_READ_ERROR;
  }

  assert(res.type == ServerMessageType_EVAL_SUCCESS);
  return libforks_OK;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rsi, (%rax)
movl $0x4, 0x10(%rax)
movl 0x4(%rdi), %edi
movl $0x18, %edx
movq %rax, %rsi
callq 0x17cb
cmpl $-0x1, %eax
je 0x246f
movl 0x4(%rbx), %edi
leaq 0xc(%rsp), %rsi
movl $0xc, %edx
callq 0x163f
cmpl $-0x1, %eax
je 0x2476
xorl %eax, %eax
cmpl $0x3, 0x14(%rsp)
je 0x247b
leaq 0xf05(%rip), %rdi       # 0x335c
leaq 0xd31(%rip), %rsi       # 0x318f
leaq 0xf22(%rip), %rcx       # 0x3387
movl $0x4ac, %edx            # imm = 0x4AC
callq 0x10b0
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x247b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/motet-a[P]libforks/libforks.c
// Function: serv_sigchld_handler
static void serv_sigchld_handler(int sig_) {
  (void)sig_;

  // This function uses `serv_DEBUG` and `serv_print_errno` which
  // could theoretically be async-signal-unsafe. But that’s only
  // when debugging is enabled or if a fatal error occurs.

  int prev_errno = errno;

  // We know that some children have exited but we don’t know which ones.
  // We can list them by calling `waitpid(-1, …, …)` repeatedly.

  serv_DEBUG("received SIGCHLD\n");

  while (true) {
    int status;
    pid_t child_pid = waitpid(-1, &status, WNOHANG);
    if (child_pid == 0 || (child_pid == -1 && errno == ECHILD)) {
      // no more stopped children
      break;
    }

    if (child_pid == -1) {
      serv_print_errno("waitpid(2) system call in SIGCHLD handler");
      serv_panic();
    }

    assert(WIFEXITED(status) || WIFSIGNALED(status));

    serv_DEBUG("child %d exited, informing main loop\n", (int)child_pid);

    libforks_ExitEvent event = {
      .pid = child_pid,
      .wait_status = status,
    };
    if (write_exact(serv_exit_pipe[WRITE_END], &event, sizeof event) == -1) {
      serv_print_errno("write(2) system call in SIGCHLD handler");
      serv_panic();
    }
  }

  serv_DEBUG("SIGCHLD handling done\n");

  errno = prev_errno;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
callq 0x1050
movq %rax, %rbx
movl (%rax), %ebp
leaq 0xc(%rsp), %r14
leaq 0x10(%rsp), %r15
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
movl $0x1, %edx
callq 0x1190
testl %eax, %eax
je 0x2601
cmpl $-0x1, %eax
je 0x25fc
movl 0xc(%rsp), %ecx
movl %ecx, %edx
andl $0x7f, %edx
je 0x25cb
shll $0x18, %edx
addl $0x1000000, %edx        # imm = 0x1000000
cmpl $0x1ffffff, %edx        # imm = 0x1FFFFFF
jle 0x260e
movl %eax, 0x10(%rsp)
movl %ecx, 0x14(%rsp)
movl 0x2b3f(%rip), %edi      # 0x5118
movl $0x8, %edx
movq %r15, %rsi
callq 0x17cb
cmpl $-0x1, %eax
jne 0x2594
leaq 0x106d(%rip), %rdi      # 0x365f
callq 0x1900
callq 0x24a0
cmpl $0xa, (%rbx)
jne 0x262d
movl %ebp, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1002(%rip), %rdi      # 0x3617
leaq 0xb73(%rip), %rsi       # 0x318f
leaq 0x101d(%rip), %rcx      # 0x3640
movl $0x1b4, %edx            # imm = 0x1B4
callq 0x10b0
leaq 0xfb9(%rip), %rdi       # 0x35ed
jmp 0x25f2
// File: /workspace/github_c_makefile_star2_O3/motet-a[P]libforks/libforks.c
// Function: serv_uninstall_signal_handler
static void serv_uninstall_signal_handler(int signal) {
  struct sigaction sa;
  sa.sa_handler = SIG_DFL;
  sa.sa_flags = 0;
  sigemptyset(&sa.sa_mask);
  if (sigaction(signal, &sa, NULL) == -1) {
    serv_print_errno(NULL);
    serv_panic();
  }
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
movl %edi, %ebx
leaq 0x10(%rsp), %rdi
movq $0x0, -0x8(%rdi)
movl $0x0, 0x80(%rdi)
callq 0x1120
leaq 0x8(%rsp), %rsi
movl %ebx, %edi
xorl %edx, %edx
callq 0x1070
cmpl $-0x1, %eax
je 0x271a
addq $0xa0, %rsp
popq %rbx
retq
xorl %edi, %edi
callq 0x1900
callq 0x24a0
// File: /workspace/github_c_makefile_star2_O3/imaya[P]zopfli-for-emscripten/blocksplitter.c
// Function: ZopfliBlockSplitSimple
void ZopfliBlockSplitSimple(const unsigned char* in,
                            size_t instart, size_t inend,
                            size_t blocksize,
                            size_t** splitpoints, size_t* npoints) {
  size_t i = instart;
  while (i < inend) {
    ZOPFLI_APPEND_DATA(i, splitpoints, npoints);
    i += blocksize;
  }
  (void)in;
}

// Assembly:
cmpq %rdx, %rsi
jae 0x1caf
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq (%r9), %rsi
leaq -0x1(%rsi), %rax
testq %rax, %rsi
jne 0x1c7d
testq %rsi, %rsi
je 0x1c82
movq (%r14), %rdi
shlq $0x4, %rsi
callq 0x1150
movq (%rbx), %rsi
jmp 0x1c8e
movq (%r14), %rax
jmp 0x1c91
movl $0x8, %edi
callq 0x1130
xorl %esi, %esi
movq %rax, (%r14)
movq %r13, (%rax,%rsi,8)
movq (%rbx), %rsi
incq %rsi
movq %rsi, (%rbx)
addq %r15, %r13
cmpq %r12, %r13
jb 0x1c5e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/imaya[P]zopfli-for-emscripten/cache.c
// Function: ZopfliSublenToCache
void ZopfliSublenToCache(const unsigned short* sublen,
                         size_t pos, size_t length,
                         ZopfliLongestMatchCache* lmc) {
  size_t i;
  size_t j = 0;
  unsigned bestlength = 0;
  unsigned char* cache;

#if ZOPFLI_CACHE_LENGTH == 0
  return;
#endif

  cache = &lmc->sublen[ZOPFLI_CACHE_LENGTH * pos * 3];
  if (length < 3) return;
  for (i = 3; i <= length; i++) {
    if (i == length || sublen[i] != sublen[i + 1]) {
      cache[j * 3] = i - 3;
      cache[j * 3 + 1] = sublen[i] % 256;
      cache[j * 3 + 2] = (sublen[i] >> 8) % 256;
      bestlength = i;
      j++;
      if (j >= ZOPFLI_CACHE_LENGTH) break;
    }
  }
  if (j < ZOPFLI_CACHE_LENGTH) {
    assert(bestlength == length);
    cache[(ZOPFLI_CACHE_LENGTH - 1) * 3] = bestlength - 3;
  } else {
    assert(bestlength <= length);
  }
  assert(bestlength == ZopfliMaxCachedSublen(lmc, pos, length));
}

// Assembly:
pushq %rax
cmpq $0x3, %rdx
jb 0x20b3
shlq $0x3, %rsi
leaq (%rsi,%rsi,2), %rax
movq 0x10(%rcx), %r8
addq %rax, %r8
xorl %esi, %esi
movl $0x3, %r9d
xorl %r10d, %r10d
cmpq %r9, %rdx
je 0x2042
movzwl (%rdi,%r9,2), %r11d
cmpw 0x2(%rdi,%r9,2), %r11w
je 0x206d
leaq (%r10,%r10,2), %rsi
leal -0x3(%r9), %r11d
movb %r11b, (%r8,%rsi)
movb (%rdi,%r9,2), %r11b
movb %r11b, 0x1(%r8,%rsi)
movb 0x1(%rdi,%r9,2), %r11b
movb %r11b, 0x2(%r8,%rsi)
incq %r10
cmpq $0x7, %r10
ja 0x208b
movl %r9d, %esi
incq %r9
cmpq %rdx, %r9
jbe 0x2030
cmpq $0x7, %r10
ja 0x208e
movl %esi, %edi
cmpq %rdx, %rdi
jne 0x20f7
leal -0x3(%rsi), %edx
movb %dl, 0x15(%r8)
jmp 0x2095
movl %r9d, %esi
movl %esi, %edi
cmpq %rdx, %rdi
ja 0x20d8
movq 0x10(%rcx), %rcx
cmpb $0x0, 0x1(%rcx,%rax)
jne 0x20a7
cmpb $0x0, 0x2(%rcx,%rax)
je 0x20b5
movzbl 0x15(%rcx,%rax), %eax
addl $0x3, %eax
cmpl %eax, %esi
jne 0x20b9
popq %rax
retq
xorl %eax, %eax
jmp 0x20af
leaq 0x821e(%rip), %rdi      # 0xa2de
leaq 0x819e(%rip), %rsi      # 0xa265
leaq 0x819f(%rip), %rcx      # 0xa26d
movl $0x4e, %edx
callq 0x10b0
leaq 0x81ea(%rip), %rdi      # 0xa2c9
leaq 0x817f(%rip), %rsi      # 0xa265
leaq 0x8180(%rip), %rcx      # 0xa26d
movl $0x4c, %edx
callq 0x10b0
leaq 0x8152(%rip), %rdi      # 0xa250
leaq 0x8160(%rip), %rsi      # 0xa265
leaq 0x8161(%rip), %rcx      # 0xa26d
movl $0x49, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/imaya[P]zopfli-for-emscripten/deflate.c
// Function: GetFixedTree
static void GetFixedTree(unsigned* ll_lengths, unsigned* d_lengths) {
  size_t i;
  for (i = 0; i < 144; i++) ll_lengths[i] = 8;
  for (i = 144; i < 256; i++) ll_lengths[i] = 9;
  for (i = 256; i < 280; i++) ll_lengths[i] = 7;
  for (i = 280; i < 288; i++) ll_lengths[i] = 8;
  for (i = 0; i < 32; i++) d_lengths[i] = 5;
}

// Assembly:
xorl %eax, %eax
movaps 0x7c80(%rip), %xmm0     # 0xa340
movups %xmm0, (%rdi,%rax,4)
addq $0x4, %rax
cmpq $0x90, %rax
jne 0x26c0
xorl %eax, %eax
movaps 0x7c77(%rip), %xmm1     # 0xa350
movups %xmm1, 0x240(%rdi,%rax,4)
addq $0x4, %rax
cmpq $0x70, %rax
jne 0x26d9
xorl %eax, %eax
movaps 0x7c6c(%rip), %xmm1     # 0xa360
movups %xmm1, 0x400(%rdi,%rax,4)
addq $0x4, %rax
cmpq $0x18, %rax
jne 0x26f4
movups %xmm0, 0x460(%rdi)
movups %xmm0, 0x470(%rdi)
xorl %eax, %eax
movaps 0x7c53(%rip), %xmm0     # 0xa370
movups %xmm0, (%rsi,%rax,4)
addq $0x4, %rax
cmpq $0x20, %rax
jne 0x271d
retq
// File: /workspace/github_c_makefile_star2_O3/imaya[P]zopfli-for-emscripten/deflate.c
// Function: DeflateSplittingFirst
static void DeflateSplittingFirst(const ZopfliOptions* options,
                                  int btype, int final,
                                  const unsigned char* in,
                                  size_t instart, size_t inend,
                                  unsigned char* bp,
                                  unsigned char** out, size_t* outsize) {
  size_t i;
  size_t* splitpoints = 0;
  size_t npoints = 0;
  if (btype == 0) {
    ZopfliBlockSplitSimple(in, instart, inend, 65535, &splitpoints, &npoints);
  } else if (btype == 1) {
    /* If all blocks are fixed tree, splitting into separate blocks only
    increases the total size. Leave npoints at 0, this represents 1 block. */
  } else {
    ZopfliBlockSplit(options, in, instart, inend,
                     options->blocksplittingmax, &splitpoints, &npoints);
  }

  for (i = 0; i <= npoints; i++) {
    size_t start = i == 0 ? instart : splitpoints[i - 1];
    size_t end = i == npoints ? inend : splitpoints[i];
    DeflateBlock(options, btype, i == npoints && final, in, start, end,
                 bp, out, outsize);
  }

  free(splitpoints);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
cmpl $0x1, %esi
je 0x2a11
testl %r12d, %r12d
jne 0x29e7
movq %rsp, %r8
leaq 0x8(%rsp), %r9
movl $0xffff, %ecx           # imm = 0xFFFF
movq %r15, %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
callq 0x1c3e
jmp 0x2a11
movslq 0x10(%r13), %r8
subq $0x8, %rsp
leaq 0x10(%rsp), %rax
leaq 0x8(%rsp), %r9
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq 0x18(%rsp), %rcx
pushq %rax
callq 0x1a82
addq $0x10, %rsp
movq 0x8(%rsp), %rax
xorl %ebx, %ebx
movq %r14, %r8
testq %rbx, %rbx
je 0x2a29
movq (%rsp), %rcx
movq -0x8(%rcx,%rbx,8), %r8
movq 0x10(%rsp), %r9
cmpq %rax, %rbx
je 0x2a3b
movq (%rsp), %rcx
movq (%rcx,%rbx,8), %r9
cmpq %rax, %rbx
sete %al
testl %ebp, %ebp
setne %cl
andb %al, %cl
movzbl %cl, %edx
subq $0x8, %rsp
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rcx
pushq 0x68(%rsp)
pushq 0x68(%rsp)
pushq 0x68(%rsp)
callq 0x2a92
addq $0x20, %rsp
incq %rbx
movq 0x8(%rsp), %rax
cmpq %rax, %rbx
jbe 0x2a18
movq (%rsp), %rdi
callq 0x1030
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/imaya[P]zopfli-for-emscripten/deflate.c
// Function: AddBits
static void AddBits(unsigned symbol, unsigned length,
                    unsigned char* bp, unsigned char** out, size_t* outsize) {
  /* TODO(lode): make more efficient (add more bits at once). */
  unsigned i;
  for (i = 0; i < length; i++) {
    unsigned bit = (symbol >> i) & 1;
    if (((*bp) & 7) == 0) ZOPFLI_APPEND_DATA(0, out, outsize);
    (*out)[*outsize - 1] |= bit << ((*bp) & 7);
    (*bp)++;
  }
}

// Assembly:
testl %esi, %esi
je 0x392c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %edx
movb (%r15), %cl
xorl %r13d, %r13d
movl %esi, 0x4(%rsp)
movl %edi, (%rsp)
xorl %r12d, %r12d
btl %r13d, %edi
setb %bpl
movq (%rbx), %rsi
andb $0x7, %cl
jne 0x3900
leaq -0x1(%rsi), %rax
testq %rax, %rsi
jne 0x38d2
testq %rsi, %rsi
je 0x38d7
movq (%r14), %rdi
addq %rsi, %rsi
callq 0x1150
movq (%rbx), %rsi
jmp 0x38e3
movq (%r14), %rax
jmp 0x38ed
movl $0x1, %edi
callq 0x1130
xorl %esi, %esi
movq %rax, (%r14)
movl 0x4(%rsp), %edx
movl (%rsp), %edi
movb $0x0, (%rax,%rsi)
movq (%rbx), %rsi
incq %rsi
movq %rsi, (%rbx)
movb (%r15), %cl
andb $0x7, %cl
movb %bpl, %r12b
shll %cl, %r12d
movq (%r14), %rax
orb %r12b, -0x1(%rax,%rsi)
movb (%r15), %cl
incb %cl
movb %cl, (%r15)
incl %r13d
cmpl %r13d, %edx
jne 0x38a1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/imaya[P]zopfli-for-emscripten/deflate.c
// Function: AddHuffmanBits
static void AddHuffmanBits(unsigned symbol, unsigned length,
                           unsigned char* bp, unsigned char** out,
                           size_t* outsize) {
  /* TODO(lode): make more efficient (add more bits at once). */
  unsigned i;
  for (i = 0; i < length; i++) {
    unsigned bit = (symbol >> (length - i - 1)) & 1;
    if (((*bp) & 7) == 0) ZOPFLI_APPEND_DATA(0, out, outsize);
    (*out)[*outsize - 1] |= bit << ((*bp) & 7);
    (*bp)++;
  }
}

// Assembly:
testl %esi, %esi
je 0x39d7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movb (%rdx), %cl
decl %ebp
movl %edi, 0x4(%rsp)
xorl %r13d, %r13d
btl %ebp, %edi
setb %r12b
movq (%rbx), %rsi
andb $0x7, %cl
jne 0x39ae
leaq -0x1(%rsi), %rax
testq %rax, %rsi
jne 0x3983
testq %rsi, %rsi
je 0x3988
movq (%r14), %rdi
addq %rsi, %rsi
callq 0x1150
movq (%rbx), %rsi
jmp 0x3994
movq (%r14), %rax
jmp 0x399b
movl $0x1, %edi
callq 0x1130
xorl %esi, %esi
movq %rax, (%r14)
movl 0x4(%rsp), %edi
movb $0x0, (%rax,%rsi)
movq (%rbx), %rsi
incq %rsi
movq %rsi, (%rbx)
movb (%r15), %cl
andb $0x7, %cl
movb %r12b, %r13b
shll %cl, %r13d
movq (%r14), %rax
orb %r13b, -0x1(%rax,%rsi)
movb (%r15), %cl
incb %cl
movb %cl, (%r15)
addl $-0x1, %ebp
jb 0x3953
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/imaya[P]zopfli-for-emscripten/hash.c
// Function: ZopfliUpdateHash
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
                ZopfliHash* h) {
  unsigned short hpos = pos & ZOPFLI_WINDOW_MASK;
#ifdef ZOPFLI_HASH_SAME
  size_t amount = 0;
#endif

  UpdateHashValue(h, pos + ZOPFLI_MIN_MATCH <= end ?
      array[pos + ZOPFLI_MIN_MATCH - 1] : 0);
  h->hashval[hpos] = h->val;
  if (h->head[h->val] != -1 && h->hashval[h->head[h->val]] == h->val) {
    h->prev[hpos] = h->head[h->val];
  }
  else h->prev[hpos] = hpos;
  h->head[h->val] = hpos;

#ifdef ZOPFLI_HASH_SAME
  /* Update "same". */
  if (h->same[(pos - 1) & ZOPFLI_WINDOW_MASK] > 1) {
    amount = h->same[(pos - 1) & ZOPFLI_WINDOW_MASK] - 1;
  }
  while (pos + amount + 1 < end &&
      array[pos] == array[pos + amount + 1] && amount < (unsigned short)(-1)) {
    amount++;
  }
  h->same[hpos] = amount;
#endif

#ifdef ZOPFLI_HASH_SAME_HASH
  h->val2 = ((h->same[hpos] - ZOPFLI_MIN_MATCH) & 255) ^ h->val;
  h->hashval2[hpos] = h->val2;
  if (h->head2[h->val2] != -1 && h->hashval2[h->head2[h->val2]] == h->val2) {
    h->prev2[hpos] = h->head2[h->val2];
  }
  else h->prev2[hpos] = hpos;
  h->head2[h->val2] = hpos;
#endif
}

// Assembly:
movl %esi, %eax
andl $0x7fff, %eax           # imm = 0x7FFF
leaq 0x3(%rsi), %r9
xorl %r8d, %r8d
cmpq %rdx, %r9
ja 0x4c8e
movzbl 0x2(%rdi,%rsi), %r8d
pushq %rbp
pushq %r14
pushq %rbx
movl 0x18(%rcx), %r10d
shll $0x5, %r10d
andl $0x7fe0, %r10d          # imm = 0x7FE0
xorl %r8d, %r10d
movl %r10d, 0x18(%rcx)
movq 0x10(%rcx), %r9
movl %esi, %r8d
andl $0x7fff, %r8d           # imm = 0x7FFF
movl %r8d, %r11d
movl %r10d, (%r9,%r11,4)
movq (%rcx), %r10
movslq 0x18(%rcx), %r11
movslq (%r10,%r11,4), %rbx
movl %eax, %ebp
cmpq $-0x1, %rbx
je 0x4cd9
cmpl %r11d, (%r9,%rbx,4)
cmovnel %eax, %ebx
movl %ebx, %ebp
movq 0x8(%rcx), %r9
movw %bp, (%r9,%r8,2)
movzwl %ax, %r9d
movl %r9d, (%r10,%r11,4)
movq 0x40(%rcx), %r10
leal -0x1(%rsi), %r11d
andl $0x7fff, %r11d          # imm = 0x7FFF
movzwl (%r10,%r11,2), %ebx
leal -0x1(%rbx), %r14d
xorl %r11d, %r11d
cmpl $0x2, %ebx
cmovaeq %r14, %r11
leaq (%rsi,%r11), %rbx
incq %rbx
cmpq %rdx, %rbx
jae 0x4d4f
addq %rsi, %rdi
incq %rdi
movb -0x1(%rdi), %bpl
movq %rsi, %rbx
notq %rbx
addq %rdx, %rbx
incq %rsi
cmpq $0xfffe, %r11           # imm = 0xFFFE
ja 0x4d4f
cmpb (%rdi,%r11), %bpl
jne 0x4d4f
leaq (%rsi,%r11), %r14
incq %r14
incq %r11
cmpq %rdx, %r14
jb 0x4d2e
movq %rbx, %r11
movw %r11w, (%r10,%r8,2)
addl $0xfd, %r11d
movzbl %r11b, %edx
xorl 0x18(%rcx), %edx
movl %edx, 0x38(%rcx)
movq 0x30(%rcx), %r10
movl %edx, (%r10,%r8,4)
movq 0x20(%rcx), %rdx
movslq 0x38(%rcx), %rsi
movslq (%rdx,%rsi,4), %rdi
cmpq $-0x1, %rdi
je 0x4d88
cmpl %esi, (%r10,%rdi,4)
cmovnel %eax, %edi
movl %edi, %eax
movq 0x28(%rcx), %rcx
movw %ax, (%rcx,%r8,2)
movl %r9d, (%rdx,%rsi,4)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/imaya[P]zopfli-for-emscripten/lz77.c
// Function: ZopfliCopyLZ77Store
void ZopfliCopyLZ77Store(
    const ZopfliLZ77Store* source, ZopfliLZ77Store* dest) {
  size_t i;
  ZopfliCleanLZ77Store(dest);
  dest->litlens =
      (unsigned short*)malloc(sizeof(*dest->litlens) * source->size);
  dest->dists = (unsigned short*)malloc(sizeof(*dest->dists) * source->size);

  if (!dest->litlens || !dest->dists) exit(-1); /* Allocation failed. */

  dest->size = source->size;
  for (i = 0; i < source->size; i++) {
    dest->litlens[i] = source->litlens[i];
    dest->dists[i] = source->dists[i];
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x1030
movq 0x8(%r15), %rdi
callq 0x1030
movq 0x10(%rbx), %r13
leaq (,%r13,2), %r12
movq %r12, %rdi
callq 0x1130
movq %rax, %r14
movq %rax, (%r15)
movq %r12, %rdi
callq 0x1130
movq %rax, 0x8(%r15)
testq %r14, %r14
je 0x68d5
testq %rax, %rax
je 0x68d5
movq %r13, 0x10(%r15)
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x68cb
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
xorl %edi, %edi
movzwl (%rdx,%rdi,2), %r8d
movw %r8w, (%r14,%rdi,2)
movzwl (%rsi,%rdi,2), %r8d
movw %r8w, (%rax,%rdi,2)
incq %rdi
cmpq %rdi, %rcx
jne 0x68af
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1180
// File: /workspace/github_c_makefile_star2_O3/imaya[P]zopfli-for-emscripten/lz77.c
// Function: ZopfliVerifyLenDist
void ZopfliVerifyLenDist(const unsigned char* data, size_t datasize, size_t pos,
                         unsigned short dist, unsigned short length) {

  /* TODO(lode): make this only run in a debug compile, it's for assert only. */
  size_t i;

  assert(pos + length <= datasize);
  for (i = 0; i < length; i++) {
    if (data[pos - dist + i] != data[pos + i]) {
      assert(data[pos - dist + i] == data[pos + i]);
      break;
    }
  }
}

// Assembly:
pushq %rax
movl %r8d, %eax
leaq (%rax,%rdx), %r9
cmpq %rsi, %r9
ja 0x69d4
testw %r8w, %r8w
je 0x69b3
leaq (%rdi,%rdx), %rsi
movzwl %cx, %ecx
subq %rcx, %rdx
addq %rdi, %rdx
xorl %ecx, %ecx
movb (%rdx,%rcx), %dil
cmpb (%rsi,%rcx), %dil
jne 0x69b5
incq %rcx
cmpq %rcx, %rax
jne 0x69a1
popq %rax
retq
leaq 0x40c4(%rip), %rdi      # 0xaa80
leaq 0x4056(%rip), %rsi      # 0xaa19
leaq 0x4056(%rip), %rcx      # 0xaa20
movl $0x5a, %edx
callq 0x10b0
leaq 0x4025(%rip), %rdi      # 0xaa00
leaq 0x4037(%rip), %rsi      # 0xaa19
leaq 0x4037(%rip), %rcx      # 0xaa20
movl $0x57, %edx
callq 0x10b0