LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/weapons.c
// Function: fallpos
bool fallpos(struct coord *pos,struct coord *newpos,bool passages)
{
	int y, x, ch;

	for (y = pos->y - 1; y <= pos->y + 1; y++) {
		for (x = pos->x - 1; x <= pos->x + 1; x++) {
			/*
			 * check to make certain the spot is empty, if it is,
			 * put the object there, set it in the level list
			 * and re-draw the room if he can see it
			 */
			if (y == hero.y && x == hero.x)
				continue;
			ch = winat(y, x);
			if (ch == FLOOR || (passages && ch == PASSAGE)) {
				newpos->y = y;
				newpos->x = x;
				return TRUE;
			}
		}
	}
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jg 0x25e8e
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jg 0x25e7e
movl -0x20(%rbp), %eax
leaq 0x112b1(%rip), %rcx     # 0x370d0
cmpl 0x54(%rcx), %eax
jne 0x25e35
movl -0x24(%rbp), %eax
leaq 0x112a2(%rip), %rcx     # 0x370d0
cmpl 0x50(%rcx), %eax
jne 0x25e35
jmp 0x25e73
movl -0x20(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0xa960
movsbl %al, %eax
movl %eax, -0x28(%rbp)
cmpl $0x2e, -0x28(%rbp)
je 0x25e58
testb $0x1, -0x19(%rbp)
je 0x25e71
cmpl $0x23, -0x28(%rbp)
jne 0x25e71
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x25e92
jmp 0x25e73
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x25e05
jmp 0x25e80
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x25de4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/weapons.c
// Function: init_weapon
void init_weapon(struct object *weap,int type)
{
	struct init_weps *iwp;

	weap->o_type = WEAPON;
	weap->o_which = type;
	iwp = &weaps[type];
	strcpy(weap->o_damage,iwp->w_dam);
	strcpy(weap->o_hurldmg,iwp->w_hrl);
	weap->o_launch = iwp->w_launch;
	weap->o_flags = iwp->w_flags;
	weap->o_weight = iwp->w_wght;
	weap->o_typname = things[TYP_WEAPON].mi_name;
	if (o_on(weap,ISMANY))
		weap->o_count = rnd(8) + 8;
	else
		weap->o_count = 1;
	weap->o_group = newgrp();
	weap->o_vol = itemvol(weap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0x29, 0x20(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movslq -0xc(%rbp), %rcx
leaq 0xf1f1(%rip), %rax      # 0x350c0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x60d0
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x60d0
movq -0x18(%rbp), %rax
movb 0x1c(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x48(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
leaq 0xee9c(%rip), %rax      # 0x34dd0
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movl $0x4000, %esi           # imm = 0x4000
callq 0xaac0
testb $0x1, %al
jne 0x25f54
jmp 0x25f6e
movl $0x8, %edi
movb $0x0, %al
callq 0xef20
movl %eax, %ecx
addl $0x8, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x25f79
movq -0x8(%rbp), %rax
movl $0x1, 0x24(%rax)
leaq 0xd384(%rip), %rax      # 0x33304
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xd378(%rip), %rax      # 0x33304
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rdi
callq 0xae90
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/weapons.c
// Function: num
char *num(int n1,int n2)
{
	static char numbuf[LINLEN];

	if (n1 == 0 && n2 == 0)
		return "+0";
	if (n2 == 0)
		sprintf(numbuf, "%s%d", n1 < 0 ? "" : "+", n1);
	else
		sprintf(numbuf,"%s%d,%s%d",n1<0 ? "":"+",n1,n2<0 ? "":"+",n2);  
	return numbuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x25fda
cmpl $0x0, -0x10(%rbp)
jne 0x25fda
leaq 0x81a8(%rip), %rax      # 0x2e179
movq %rax, -0x8(%rbp)
jmp 0x26069
cmpl $0x0, -0x10(%rbp)
jne 0x26012
movl -0xc(%rbp), %ecx
leaq 0x8192(%rip), %rdx      # 0x2e17c
leaq 0x82be(%rip), %rax      # 0x2e2af
cmpl $0x0, %ecx
cmovlq %rax, %rdx
movl -0xc(%rbp), %ecx
leaq 0x1695e(%rip), %rdi     # 0x3c960
leaq 0x817a(%rip), %rsi      # 0x2e183
movb $0x0, %al
callq 0x64f0
jmp 0x2605e
movl -0xc(%rbp), %ecx
leaq 0x8160(%rip), %rdx      # 0x2e17c
leaq 0x828c(%rip), %rax      # 0x2e2af
cmpl $0x0, %ecx
cmovlq %rax, %rdx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %esi
leaq 0x8145(%rip), %r8       # 0x2e17c
leaq 0x8271(%rip), %rax      # 0x2e2af
cmpl $0x0, %esi
cmovlq %rax, %r8
movl -0x10(%rbp), %r9d
leaq 0x16910(%rip), %rdi     # 0x3c960
leaq 0x8127(%rip), %rsi      # 0x2e17e
movb $0x0, %al
callq 0x64f0
leaq 0x168fb(%rip), %rax     # 0x3c960
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/weapons.c
// Function: wield
int wield()
{
	struct linked_list *item;
	struct object *obj, *oweapon;

	oweapon = cur_weapon;
	if (!dropcheck(cur_weapon)) {
		cur_weapon = oweapon;
		return 0;
	}
	cur_weapon = oweapon;
	if ((item = get_item("wield", WEAPON)) == NULL)
		return 0;
	obj = OBJPTR(item);
	if (is_current(obj)) {
		after = FALSE;
		return 0;
	}
	msg("Wielding %s", inv_name(obj, TRUE));
	cur_weapon = obj;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10c31(%rip), %rax     # 0x36cc0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x10c23(%rip), %rax     # 0x36cc0
movq (%rax), %rdi
callq 0x23eb0
testb $0x1, %al
jne 0x260c3
movq -0x20(%rbp), %rcx
leaq 0x10c0c(%rip), %rax     # 0x36cc0
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x26157
movq -0x20(%rbp), %rcx
leaq 0x10bf2(%rip), %rax     # 0x36cc0
movq %rcx, (%rax)
leaq 0x80b0(%rip), %rdi      # 0x2e188
movl $0x29, %esi
callq 0x14b90
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x260f5
movl $0x0, -0x4(%rbp)
jmp 0x26157
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xffc0
testb $0x1, %al
jne 0x26110
jmp 0x26123
leaq 0xd1f6(%rip), %rax      # 0x3330d
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x26157
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x23060
movq %rax, %rsi
leaq 0x8053(%rip), %rdi      # 0x2e18e
movb $0x0, %al
callq 0xd8f0
movq -0x18(%rbp), %rcx
leaq 0x10b73(%rip), %rax     # 0x36cc0
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/wizard.c
// Function: makemons
int makemons(int what)
{
	int x, y, oktomake = FALSE, appear = 1;
	struct coord mp;

	oktomake = FALSE;
	for (x = hero.x - 1 ; x <= hero.x + 1 ; x++) {
		for (y = hero.y - 1 ; y <= hero.y + 1 ; y++) {
			if (x != hero.x || y != hero.y) {
				if (step_ok(winat(y, x)) && rnd(++appear) == 0) {
					mp.x = x;
					mp.y = y;
					oktomake = TRUE;
					break;
				}
			}
		}
	}
	if (oktomake) {
		new_monster(midx(what), &mp, FALSE);
		look(FALSE);
	}
	return oktomake;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
leaq 0x105b9(%rip), %rax     # 0x370d0
movl 0x50(%rax), %eax
subl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0x105a6(%rip), %rcx     # 0x370d0
movl 0x50(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jg 0x26be0
leaq 0x10591(%rip), %rax     # 0x370d0
movl 0x54(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x1057e(%rip), %rcx     # 0x370d0
movl 0x54(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jg 0x26bd0
movl -0x8(%rbp), %eax
leaq 0x1056a(%rip), %rcx     # 0x370d0
cmpl 0x50(%rcx), %eax
jne 0x26b7a
movl -0xc(%rbp), %eax
leaq 0x1055b(%rip), %rcx     # 0x370d0
cmpl 0x54(%rcx), %eax
je 0x26bc0
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0xa960
movsbq %al, %rdi
callq 0xdc30
testb $0x1, %al
jne 0x26b94
jmp 0x26bbe
movl -0x14(%rbp), %edi
addl $0x1, %edi
movl %edi, -0x14(%rbp)
movb $0x0, %al
callq 0xef20
cmpl $0x0, %eax
jne 0x26bbe
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x1, -0x10(%rbp)
jmp 0x26bd0
jmp 0x26bc0
jmp 0x26bc2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x26b48
jmp 0x26bd2
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x26b20
cmpl $0x0, -0x10(%rbp)
je 0x26c06
movl -0x4(%rbp), %eax
movsbl %al, %edi
callq 0x10400
leaq -0x1c(%rbp), %rsi
xorl %edx, %edx
movsbl %al, %edi
callq 0x10550
xorl %edi, %edi
callq 0xf540
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/wizard.c
// Function: getbless
int getbless()
{
	int bless;

	msg("Blessing: ");
	prbuf[0] = '\0';
	bless = get_str(prbuf, cw);
	if (bless == NORM)
		bless = atoi(prbuf);
	else
		bless = 0;
	return bless;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x7710(%rip), %rdi      # 0x2e32f
movb $0x0, %al
callq 0xd8f0
leaq 0x106d3(%rip), %rax     # 0x37300
movb $0x0, (%rax)
leaq 0x13219(%rip), %rax     # 0x39e50
movq (%rax), %rsi
leaq 0x106bf(%rip), %rdi     # 0x37300
callq 0x13c10
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x26c60
leaq 0x106aa(%rip), %rdi     # 0x37300
callq 0x64b0
movl %eax, -0x4(%rbp)
jmp 0x26c67
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/wizard.c
// Function: passwd
bool passwd()
{
	char *sp, c;
	bool passok;
	char buf[LINLEN], *xcrypt();

	msg(wizstr);
	mpos = 0;
	sp = buf;
	while ((c = getchar()) != '\n' && c != '\r' && c != ESCAPE)
	if (c == terminal.c_cc[VKILL])
		sp = buf;
	else if (c == terminal.c_cc[VERASE] && sp > buf)
		sp--;
	else
		*sp++ = c;
	if (sp == buf)
		passok = FALSE;
	else {
		*sp = '\0';
		passok = (strcmp(PASSWD, xcrypt(buf, "mT")) == 0);
	}
	return passok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0xc451(%rip), %rdi      # 0x33360
movb $0x0, %al
callq 0xd8f0
leaq 0xfdc3(%rip), %rax      # 0x36ce0
movl $0x0, (%rax)
leaq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
callq 0x6270
movb %al, -0x9(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x61(%rbp)
je 0x26f5b
movsbl -0x9(%rbp), %ecx
xorl %eax, %eax
cmpl $0xd, %ecx
movb %al, -0x61(%rbp)
je 0x26f5b
movsbl -0x9(%rbp), %eax
cmpl $0x1b, %eax
setne %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x26f64
jmp 0x26fca
movsbl -0x9(%rbp), %eax
leaq 0x14f61(%rip), %rcx     # 0x3bed0
movzbl 0x14(%rcx), %ecx
cmpl %ecx, %eax
jne 0x26f81
leaq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x26fc5
movsbl -0x9(%rbp), %eax
leaq 0x14f44(%rip), %rcx     # 0x3bed0
movzbl 0x13(%rcx), %ecx
cmpl %ecx, %eax
jne 0x26faf
movq -0x8(%rbp), %rax
leaq -0x60(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x26faf
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x26fc3
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x26fc5
jmp 0x26f2b
movq -0x8(%rbp), %rax
leaq -0x60(%rbp), %rcx
cmpq %rcx, %rax
jne 0x26fdd
movb $0x0, -0xa(%rbp)
jmp 0x27010
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
leaq -0x60(%rbp), %rdi
leaq 0x3fbb(%rip), %rsi      # 0x2afaa
movb $0x0, %al
callq 0x27020
movq %rax, %rsi
leaq 0x3f9c(%rip), %rdi      # 0x2af9c
callq 0x6250
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/xcrypt.c
// Function: ascii_to_bin
static __inline int ascii_to_bin(char ch)
{
	if (ch > 'z')
		return(0);
	if (ch >= 'a')
		return(ch - 'a' + 38);
	if (ch > 'Z')
		return(0);
	if (ch >= 'A')
		return(ch - 'A' + 12);
	if (ch > '9')
		return(0);
	if (ch >= '.')
		return(ch - '.');
	return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x7a, %eax
jle 0x2795c
movl $0x0, -0x4(%rbp)
jmp 0x279cc
movsbl -0x5(%rbp), %eax
cmpl $0x61, %eax
jl 0x27974
movsbl -0x5(%rbp), %eax
subl $0x61, %eax
addl $0x26, %eax
movl %eax, -0x4(%rbp)
jmp 0x279cc
movsbl -0x5(%rbp), %eax
cmpl $0x5a, %eax
jle 0x27986
movl $0x0, -0x4(%rbp)
jmp 0x279cc
movsbl -0x5(%rbp), %eax
cmpl $0x41, %eax
jl 0x2799e
movsbl -0x5(%rbp), %eax
subl $0x41, %eax
addl $0xc, %eax
movl %eax, -0x4(%rbp)
jmp 0x279cc
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jle 0x279b0
movl $0x0, -0x4(%rbp)
jmp 0x279cc
movsbl -0x5(%rbp), %eax
cmpl $0x2e, %eax
jl 0x279c5
movsbl -0x5(%rbp), %eax
subl $0x2e, %eax
movl %eax, -0x4(%rbp)
jmp 0x279cc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/xcrypt.c
// Function: des_cipher
static int des_cipher(const char *in,char *out,int salt,int count)
{
	unsigned int l_out, r_out, rawl, rawr;
	unsigned int x[2];
	int	retval;

	if (!des_initialised)
		des_init();

	setup_salt(salt);

	memcpy(x, in, sizeof x);
	rawl = ntohl(x[0]);
	rawr = ntohl(x[1]);
	retval = do_des(rawl, rawr, &l_out, &r_out, count);

	x[0] = htonl(l_out);
	x[1] = htonl(r_out);
	memcpy(out, x, sizeof x);
	return(retval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpl $0x0, 0x14fcb(%rip)     # 0x3c9c8
jne 0x27a04
callq 0x280c0
movl -0x14(%rbp), %edi
callq 0x27a80
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x30(%rbp), %edi
callq 0x6540
movl %eax, -0x24(%rbp)
movl -0x2c(%rbp), %edi
callq 0x6540
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
movl -0x18(%rbp), %r8d
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x27b00
movl %eax, -0x34(%rbp)
movl -0x1c(%rbp), %edi
callq 0x6210
movl %eax, -0x30(%rbp)
movl -0x20(%rbp), %edi
callq 0x6210
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ajpaulson[P]srogue11/xcrypt.c
// Function: setup_salt
static void setup_salt(int salt)
{
	unsigned int	obit, saltbit;
	int	i;

	if (salt == old_salt)
		return;
	old_salt = salt;

	saltbits = 0;
	saltbit = 1;
	obit = 0x800000;
	for (i = 0; i < 24; i++) {
		if (salt & saltbit)
			saltbits |= obit;
		saltbit <<= 1;
		obit >>= 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x14f48(%rip), %eax     # 0x3c9d8
jne 0x27a94
jmp 0x27af7
movl -0x4(%rbp), %eax
movl %eax, 0x14f3b(%rip)     # 0x3c9d8
movl $0x0, 0x14f2d(%rip)     # 0x3c9d4
movl $0x1, -0xc(%rbp)
movl $0x800000, -0x8(%rbp)   # imm = 0x800000
movl $0x0, -0x10(%rbp)
cmpl $0x18, -0x10(%rbp)
jge 0x27af7
movl -0x4(%rbp), %eax
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
je 0x27adc
movl -0x8(%rbp), %eax
orl 0x14efe(%rip), %eax     # 0x3c9d4
movl %eax, 0x14ef8(%rip)     # 0x3c9d4
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, -0x8(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x27abc
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/dnsthread-resolve/main.c
// Function: main
int
main(int argc, char ** argv)
{

	WARNP_INIT;

	/* Usage. */
	if (argc < 2) {
		fprintf(stderr, "usage: dnsthread-resolve ADDRESS\n");
		goto err0;
	}

	/* Look for address given. */
	if (dnsthread_resolve(argv[1], found, NULL)) {
		warn0("fail dns");
		goto err0;
	}

	/* Loop until we're done. */
	if (events_spin(&doneloop)) {
		warn0("Error running event loop");
		goto err0;
	}

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x24fc
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x63c0
jmp 0x24fe
cmpl $0x2, -0x8(%rbp)
jge 0x251e
movq 0xaaed(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x6aef(%rip), %rsi      # 0x9004
movb $0x0, %al
callq 0x2200
jmp 0x258d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x73(%rip), %rsi        # 0x25a0
xorl %eax, %eax
movl %eax, %edx
callq 0x73f0
cmpl $0x0, %eax
je 0x2558
jmp 0x253d
leaq 0x6ae2(%rip), %rdi      # 0x9026
movb $0x0, %al
callq 0x66d0
callq 0x2090
movl $0x0, (%rax)
jmp 0x258d
leaq 0xaf35(%rip), %rdi      # 0xd494
callq 0x2920
cmpl $0x0, %eax
je 0x2586
jmp 0x256b
leaq 0x6abd(%rip), %rdi      # 0x902f
movb $0x0, %al
callq 0x66d0
callq 0x2090
movl $0x0, (%rax)
jmp 0x258d
xorl %edi, %edi
callq 0x2330
movl $0x1, %edi
callq 0x2330
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/tests/dnsthread-resolve/main.c
// Function: found
static int
found(void * cookie, struct sock_addr ** sas)
{
	char * addr;
	int i;

	(void)cookie; /* UNUSED */

	/* Sanity check. */
	if (sas == NULL)
		goto err0;

	/* Print each address. */
	for (i = 0; i < MAX_ADDRS; i++) {
		if (sas[i] == NULL)
			break;

		/* Extract address and print it. */
		if ((addr = sock_addr_prettyprint(sas[i])) == NULL) {
			warn0("sock_addr_prettyprint()");
			goto err1;
		}
		printf("%s\n", addr);

		/* Clean up. */
		free(addr);
	}

	/* Clean up. */
	sock_addr_freelist(sas);

	/* Quit event loop. */
	doneloop = 1;

	/* Success! */
	return (0);

err1:
	sock_addr_freelist(sas);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x25bc
jmp 0x265d
movl $0x0, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jge 0x2638
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x25da
jmp 0x2638
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5fc0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2612
jmp 0x25f7
leaq 0x6a4a(%rip), %rdi      # 0x9048
movb $0x0, %al
callq 0x66d0
callq 0x2090
movl $0x0, (%rax)
jmp 0x2654
movq -0x20(%rbp), %rsi
leaq 0x71ec(%rip), %rdi      # 0x9809
movb $0x0, %al
callq 0x2140
movq -0x20(%rbp), %rdi
callq 0x2040
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x25c3
movq -0x18(%rbp), %rdi
callq 0x5450
movl $0x1, 0xae49(%rip)      # 0xd494
movl $0x0, -0x4(%rbp)
jmp 0x2664
movq -0x18(%rbp), %rdi
callq 0x5450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../lib/dnsthread/dnsthread.c
// Function: callback_resolveone
static int
callback_resolveone(void * cookie)
{
	struct dnsthread_internal * T = cookie;
	struct sock_addr ** sas;
	uint8_t zero;
	int res_errno = 0;
	int (* callback)(void *, struct sock_addr **);
	void * cb_cookie;
	int rc;

	/* Drain the byte from the socketpair. */
	if (read(T->wakeupsock[1], &zero, 1) != 1) {
		warn0("Error reading from wakeup socket");
		goto err0;
	}

	/* Grab the mutex. */
	if ((rc = pthread_mutex_lock(&T->mtx)) != 0) {
		warn0("pthread_mutex_lock: %s", strerror(rc));
		goto err0;
	}

	/* Free the (strduped) address which was to be resolved. */
	free(T->addr);

	/* Grab the result. */
	sas = T->sas;
	res_errno = T->res_errno;

	/* Grab the callback. */
	callback = T->callback;
	cb_cookie = T->cookie;

	/* Release the mutex. */
	if ((rc = pthread_mutex_unlock(&T->mtx)) != 0) {
		warn0("pthread_mutex_unlock: %s", strerror(rc));
		goto err0;
	}

	/* Perform the callback. */
	if (sas == NULL)
		errno = res_errno;
	return ((callback)(cb_cookie, sas));

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x68(%rax), %edi
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
callq 0x21c0
cmpq $0x1, %rax
je 0x7186
jmp 0x7168
leaq 0x27cc(%rip), %rdi      # 0x993b
movb $0x0, %al
callq 0x66d0
callq 0x2090
movl $0x0, (%rax)
jmp 0x7271
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x23a0
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x71c6
jmp 0x719d
movl -0x3c(%rbp), %edi
callq 0x2380
movq %rax, %rsi
leaq 0x2675(%rip), %rdi      # 0x9824
movb $0x0, %al
callq 0x66d0
callq 0x2090
movl $0x0, (%rax)
jmp 0x7271
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x2040
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x2250
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x7247
jmp 0x7221
movl -0x3c(%rbp), %edi
callq 0x2380
movq %rax, %rsi
leaq 0x263c(%rip), %rdi      # 0x986f
movb $0x0, %al
callq 0x66d0
callq 0x2090
movl $0x0, (%rax)
jmp 0x7271
cmpq $0x0, -0x20(%rbp)
jne 0x725e
movl -0x28(%rbp), %eax
movl %eax, -0x40(%rbp)
callq 0x2090
movl -0x40(%rbp), %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x7278
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../lib/dnsthread/dnsthread.c
// Function: dnsthread_kill
int
dnsthread_kill(DNSTHREAD T)
{
	int rc;
	int ostate;
	pthread_t thr;

	/* Lock the control structure. */
	if ((rc = pthread_mutex_lock(&T->mtx)) != 0) {
		warn0("pthread_mutex_lock: %s", strerror(rc));
		goto err0;
	}

	/* Remember what state the thread is currently in. */
	ostate = T->state;

	/* Grab the thread ID. */
	thr = T->thr;

	/* Tell the thread to die, and wake it up. */
	T->state = THREAD_SUICIDE;
	if ((rc = pthread_cond_signal(&T->cv)) != 0) {
		warn0("pthread_cond_signal: %s", strerror(rc));
		goto err1;
	}

	/* Unlock the control structure. */
	if ((rc = pthread_mutex_unlock(&T->mtx)) != 0) {
		warn0("pthread_mutex_unlock: %s", strerror(rc));
		goto err0;
	}

	/* If the thread was sleeping, wait for it to wake up and die. */
	if (ostate == THREAD_SLEEPING) {
		if ((rc = pthread_join(thr, NULL)) != 0) {
			warn0("pthread_join: %s", strerror(rc));
			goto err0;
		}
	}

	/* Success! */
	return (0);

err1:
	pthread_mutex_unlock(&T->mtx);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x23a0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x72dc
jmp 0x72b3
movl -0x14(%rbp), %edi
callq 0x2380
movq %rax, %rsi
leaq 0x255f(%rip), %rdi      # 0x9824
movb $0x0, %al
callq 0x66d0
callq 0x2090
movl $0x0, (%rax)
jmp 0x73d4
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x2, 0x60(%rax)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x21e0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x733c
jmp 0x7313
movl -0x14(%rbp), %edi
callq 0x2380
movq %rax, %rsi
leaq 0x2563(%rip), %rdi      # 0x9888
movb $0x0, %al
callq 0x66d0
callq 0x2090
movl $0x0, (%rax)
jmp 0x73c7
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x2250
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x7379
jmp 0x7353
movl -0x14(%rbp), %edi
callq 0x2380
movq %rax, %rsi
leaq 0x250a(%rip), %rdi      # 0x986f
movb $0x0, %al
callq 0x66d0
callq 0x2090
movl $0x0, (%rax)
jmp 0x73d4
cmpl $0x0, -0x18(%rbp)
jne 0x73be
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2360
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x73bc
jmp 0x7396
movl -0x14(%rbp), %edi
callq 0x2380
movq %rax, %rsi
leaq 0x251a(%rip), %rdi      # 0x98c2
movb $0x0, %al
callq 0x66d0
callq 0x2090
movl $0x0, (%rax)
jmp 0x73d4
jmp 0x73be
movl $0x0, -0x4(%rbp)
jmp 0x73db
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x2250
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../lib/dnsthread/dnsthread.c
// Function: dnsthread_resolve
int
dnsthread_resolve(const char * addr,
    int (* callback)(void *, struct sock_addr **), void * cookie)
{
	struct resolve_cookie * R;

	/* Bake a cookie. */
	if ((R = malloc(sizeof(struct resolve_cookie))) == NULL)
		goto err0;
	R->callback = callback;
	R->cookie = cookie;

	/* Spawn a thread. */
	if ((R->T = dnsthread_spawn()) == NULL)
		goto err1;

	/* Launch the request. */
	if (dnsthread_resolveone(R->T, addr, callback_resolve, R))
		goto err2;

	/* Success! */
	return (0);

err2:
	dnsthread_kill(R->T);
err1:
	free(R);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x18, %edi
callq 0x2260
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x741a
jmp 0x7488
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x6910
movq -0x28(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x7446
jmp 0x747f
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq 0x43(%rip), %rdx        # 0x74a0
callq 0x6f60
cmpl $0x0, %eax
je 0x7469
jmp 0x7472
movl $0x0, -0x4(%rbp)
jmp 0x748f
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7290
movq -0x28(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]spiped/liball/../lib/dnsthread/dnsthread.c
// Function: callback_resolve
static int
callback_resolve(void * cookie, struct sock_addr ** sas)
{
	struct resolve_cookie * R = cookie;
	int rc;

	/* Invoke the upstream callback. */
	rc = (R->callback)(R->cookie, sas);

	/* Kill the resolver thread. */
	if (dnsthread_kill(R->T))
		rc = -1;

	/* Free our cookie. */
	free(R);

	/* Return upstream return code or failure. */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7290
cmpl $0x0, %eax
je 0x74e9
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rdi
callq 0x2040
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/Multi-producer_Multi-consumer_Lock-Synchronized_boost/code07.cpp
// Function: producer()
void producer(void)
{
	for (int i = 0; i != iterations; ++i) {
		// the addition is mutually exclusive
		myMutex1.lock();
		queue.push_front(++producer_count);
		myMutex1.unlock();
	}
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
cmpl $0x989680, 0x4(%rsp)    # imm = 0x989680
je 0x135a
leaq 0x5dde(%rip), %rdi      # 0x70f8
callq 0x1890
movl 0x5dc7(%rip), %eax      # 0x70ec
addl $0x1, %eax
movl %eax, 0x5dbe(%rip)      # 0x70ec
leaq 0x5deb(%rip), %rdi      # 0x7120
leaq 0x5db0(%rip), %rsi      # 0x70ec
callq 0x18c0
leaq 0x5db0(%rip), %rdi      # 0x70f8
callq 0x1920
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1309
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/Multi-producer_Multi-consumer_Lock-Synchronized_boost/code07.cpp
// Function: consumer()
void consumer(void)
{
	int value =0;
	while (!done) {
		myMutex1.lock();
		if (!queue.empty()) {
			value += queue.front();
			++consumer_count;
			queue.pop_front();
		}
		else if(producer_count >= iterations) {
			myMutex1.unlock();
			return;
		}
		myMutex1.unlock();
	}
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
movb 0x5e01(%rip), %al       # 0x7170
xorb $-0x1, %al
testb $0x1, %al
jne 0x1377
jmp 0x13f3
leaq 0x5d7a(%rip), %rdi      # 0x70f8
callq 0x1890
leaq 0x5d96(%rip), %rdi      # 0x7120
callq 0x1930
testb $0x1, %al
jne 0x13c6
leaq 0x5d86(%rip), %rdi      # 0x7120
callq 0x1950
movl (%rax), %eax
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x5d41(%rip), %eax      # 0x70f0
addl $0x1, %eax
movl %eax, 0x5d38(%rip)      # 0x70f0
leaq 0x5d61(%rip), %rdi      # 0x7120
callq 0x1980
jmp 0x13e2
cmpl $0x989680, 0x5d1c(%rip) # imm = 0x989680
jl 0x13e0
leaq 0x5d1f(%rip), %rdi      # 0x70f8
callq 0x1920
jmp 0x13f3
jmp 0x13e2
leaq 0x5d0f(%rip), %rdi      # 0x70f8
callq 0x1920
jmp 0x1369
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/slimox-buf.h
// Function: buf_append
static inline void buf_append(buf_t* buf, uint8_t byte) {
    if(buf->m_size == buf->m_capacity) {
        buf->m_capacity = buf->m_size * 1.2 + 1;
        buf->m_data = realloc(buf->m_data, buf->m_capacity);
    }
    buf->m_data[buf->m_size++] = byte;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0xddd3
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
cvtsi2sd %rax, %xmm0
movsd 0xa2ea(%rip), %xmm1     # 0x18080
mulsd %xmm1, %xmm0
movsd 0xa2e6(%rip), %xmm1     # 0x18088
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %esi
callq 0x11c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movb -0x9(%rbp), %dl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x8(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x8(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/slimox-match.h
// Function: matcher_init
static inline void matcher_init(matcher_t* matcher) {
    matcher->m_lzp8 = calloc((1 << 20), sizeof(uint64_t));
    matcher->m_lzp4 = calloc((1 << 20), sizeof(uint64_t));
    matcher->m_lzp2 = calloc((1 << 16), sizeof(uint32_t));
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x100000, %edi         # imm = 0x100000
movl $0x8, %esi
callq 0x1120
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x100000, %edi         # imm = 0x100000
movl $0x8, %esi
callq 0x1120
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x10000, %edi          # imm = 0x10000
movl $0x4, %esi
callq 0x1120
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/slimox-codec.c
// Function: lzmatch_thread
static inline void* lzmatch_thread(lzmatch_thread_param_pack_t* args) { /* thread for finding matches */
    uint32_t match_len;
    uint32_t mpos = args->m_mpos[0];
    uint32_t midx = 0;
    uint32_t i;

    while(mpos < args->m_ib->m_size && midx < MLEN_SIZE) {
        match_len = 1;
        if(mpos > 16 && mpos + 512 < args->m_ib->m_size) { /* find a match -- avoid overflow */
            match_len = matcher_lookup(args->m_matcher, args->m_ib->m_data, mpos);
            if(match_len < match_min) {
                match_len = 1;
            }
            for(i = 0; i < match_len; i++) {
                matcher_update(args->m_matcher, args->m_ib->m_data, mpos + i, 1);
            }
        }
        mpos += match_len;
        args->m_mlen[midx++] = match_len;
    }

    if(midx < MLEN_SIZE) { /* put an END flag */
        args->m_mlen[midx++] = 0;
    }
    args->m_mpos[0] = mpos;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
xorl %eax, %eax
cmpl 0x8(%rdx), %ecx
movb %al, -0x19(%rbp)
jae 0xdea2
cmpl $0xfa00, -0x14(%rbp)    # imm = 0xFA00
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xdeae
jmp 0xdf61
movl $0x1, -0xc(%rbp)
cmpl $0x10, -0x10(%rbp)
jbe 0xdf38
movl -0x10(%rbp), %eax
addl $0x200, %eax            # imm = 0x200
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jae 0xdf38
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
movl -0x10(%rbp), %edx
callq 0x15650
movl %eax, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jae 0xdefa
movl $0x1, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0xdf36
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
movl -0x10(%rbp), %edx
addl -0x18(%rbp), %edx
movl $0x1, %ecx
callq 0x153f0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xdf01
jmp 0xdf38
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
jmp 0xde80
cmpl $0xfa00, -0x14(%rbp)    # imm = 0xFA00
jae 0xdf86
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movl %ecx, %ecx
movl $0x0, (%rax,%rcx,4)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/slimox-alloc.h
// Function: allocator_alloc
static inline void* allocator_alloc(allocator_t* allocator, int nsize, int npoolsize) {
    allocator_block_t*   block;
    allocator_element_t* node;
    int i;

    if(!allocator->m_freelist) { /* freelist is empty, allocate more nodes */
        block = (allocator_block_t*)malloc(sizeof(allocator_block_t) + (nsize * npoolsize));
        block->m_next = allocator->m_blocklist;
        __allocator_data(block, nsize, 0)->m_next = NULL;
        for(i = 1; i < npoolsize; i++) {
            __allocator_data(block, nsize, i)->m_next = __allocator_data(block, nsize, i - 1);
        }
        allocator->m_blocklist = block;
        allocator->m_freelist = __allocator_data(block, nsize, npoolsize - 1);
    }
    node = allocator->m_freelist;
    allocator->m_freelist = allocator->m_freelist->m_next;
    return (void*)node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xe38c
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movslq %eax, %rdi
addq $0x8, %rdi
callq 0x1190
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
imull $0x0, -0xc(%rbp), %ecx
movslq %ecx, %rcx
movq $0x0, 0x8(%rax,%rcx)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xe360
movq -0x18(%rbp), %rdx
addq $0x8, %rdx
movl -0xc(%rbp), %eax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
imull %ecx, %eax
cltq
addq %rax, %rdx
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
imull -0x24(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, 0x8(%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xe321
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
addq $0x8, %rcx
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %edx
subl $0x1, %edx
imull %edx, %eax
cltq
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/slimox-ppm.h
// Function: _ppm_see_update
static inline void __ppm_see_update(see_model_t* see, int c, int update) {
    if((see->m_c[c] += update) > 16000) {
        see->m_c[0] = (see->m_c[0] + 1) / 2;
        see->m_c[1] = (see->m_c[1] + 1) / 2;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movzwl (%rcx,%rdx,2), %eax
addl %esi, %eax
movw %ax, (%rcx,%rdx,2)
movzwl %ax, %eax
cmpl $0x3e80, %eax           # imm = 0x3E80
jle 0xe787
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/slimox-match.h
// Function: matcher_free
static inline void matcher_free(matcher_t* matcher) {
    free(matcher->m_lzp8);
    free(matcher->m_lzp4);
    free(matcher->m_lzp2);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/slimox-match.h
// Function: matcher_lookup
static inline uint32_t matcher_lookup(matcher_t* matcher, unsigned char* data, uint32_t pos) {
    uint32_t match_pos = matcher_getpos(matcher, data, pos);
    uint32_t match_len = 0;

    /* match content */
    while(match_pos != 0 && match_len < match_max && data[match_pos + match_len] == data[pos + match_len]) {
        match_len++;
    }
    return (match_len >= match_min) ? match_len : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x15250
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x18(%rbp)
movb %al, -0x1d(%rbp)
je 0x156be
xorl %eax, %eax
cmpl $0xff, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jae 0x156be
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
addl -0x1c(%rbp), %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x156c7
jmp 0x156d2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1567d
cmpl $0x8, -0x1c(%rbp)
jb 0x156e0
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x156ea
movl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x156ea
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/slimox-alloc.h
// Function: allocator_free
static inline void allocator_free(allocator_t* allocator, void* node) {
    allocator_element_t* element = (allocator_element_t*)node;
    element->m_next = allocator->m_freelist;
    allocator->m_freelist = element;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/slimox-buf.h
// Function: buf_resize
static inline void buf_resize(buf_t* buf, uint32_t size) {
    if(size > buf->m_capacity || size < buf->m_capacity / 2) {
        buf->m_capacity = size * 1.2;
        buf->m_data = realloc(buf->m_data, buf->m_capacity);
    }
    buf->m_size = size;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
ja 0x15abb
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
shrl %ecx
cmpl %ecx, %eax
jae 0x15afc
movl -0xc(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0x25b5(%rip), %xmm1     # 0x18080
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %esi
callq 0x11c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/slimox-ppm.h
// Function: ppm_model_del
static inline void ppm_model_del(ppm_model_t* model) {
    allocator_del(model->m_o4_allocator);
    allocator_del(model->m_o2_allocator);
    free(model);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x2a0820(%rax), %rdi
callq 0x15da0
movq -0x8(%rbp), %rax
movq 0x2a0818(%rax), %rdi
callq 0x15da0
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/slimox-buf.h
// Function: buf_new
static inline buf_t* buf_new() {
    buf_t* buf = malloc(sizeof(buf_t));
    buf->m_data = NULL;
    buf->m_size = 0;
    buf->m_capacity = 0;
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x1190
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/slimox-alloc.h
// Function: allocator_del
static inline void allocator_del(allocator_t* allocator) {
    allocator_block_t* block;
    while(allocator->m_blocklist) {
        block = allocator->m_blocklist;
        allocator->m_blocklist = allocator->m_blocklist->m_next;
        free(block);
    }
    free(allocator);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x15ddd
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x15dac
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/slimox-pack.c
// Function: file_item_put
static inline void file_item_put(struct file_item* item, FILE* fp) {
    size_t i;

    fwrite(&item->m_mode, sizeof(item->m_mode), 1, fp);
    fwrite(&item->m_size, sizeof(item->m_size), 1, fp);
    fwrite(&item->m_path_to_root->len, sizeof(item->m_path_to_root->len), 1, fp);

    for(i = 0; i < item->m_path_to_root->len; i++) {
        if(item->m_path_to_root->str[i] == PATH_SEP[0]) { /* replace path seperator with 0 */
            fputc(0, fp);
        } else {
            fputc(item->m_path_to_root->str[i], fp);
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1220
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1220
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x1220
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq (%rcx), %rax
jae 0x1654f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl 0x22fe(%rip), %ecx      # 0x1880f
cmpl %ecx, %eax
jne 0x16522
movq -0x10(%rbp), %rsi
xorl %edi, %edi
callq 0x1110
jmp 0x1653f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edi
movq -0x10(%rbp), %rsi
callq 0x1110
jmp 0x16541
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x164e5
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/utils/string-utils.h
// Function: str_new_with
static inline string_t* str_new_with(const char* s) {
    string_t* str;
    size_t slen = strlen(s);

    if((str = malloc(sizeof(string_t))) != NULL) {
        if((str->str = malloc(slen + 4)) != NULL) {
            strcpy(str->str, s);
            str->len = slen;
            str->capacity = slen + 4;
            return str;
        }
        free(str);
    }
    STRING_UTILS_ON_ALLOC_FAIL();
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10b0
movq %rax, -0x18(%rbp)
movl $0x18, %edi
callq 0x1190
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x16617
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
callq 0x1190
movq -0x10(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x1660e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x1050
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
addq $0x4, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x1030
movq 0x49da(%rip), %rax      # 0x1aff8
movq (%rax), %rdi
leaq 0x21cc(%rip), %rsi      # 0x187f4
movb $0x0, %al
callq 0x1150
callq 0x1040
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dolphinking[P]slimox/src/slimox-pack.c
// Function: file_item_get
static inline void file_item_get(struct file_item* item, FILE* fp) {
    size_t len;
    size_t i;
    int c;

    fread(&item->m_mode, sizeof(item->m_mode), 1, fp);
    fread(&item->m_size, sizeof(item->m_size), 1, fp);
    fread(&len, sizeof(item->m_path_to_root->len), 1, fp);

    str_assign(item->m_path_to_root, "");
    for(i = 0; i < len; i++) {
        if((c = getc(fp)) == 0) { /* replace 0 with path seperator */
            str_concat_chr(item->m_path_to_root, PATH_SEP[0]);
        } else {
            str_concat_chr(item->m_path_to_root, c);
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1070
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1070
movq -0x10(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x1070
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x1fff(%rip), %rsi      # 0x18797
callq 0x16fa0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x167f6
movq -0x10(%rbp), %rdi
callq 0x1240
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jne 0x167d6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movsbl 0x2040(%rip), %esi      # 0x1880f
callq 0x171d0
jmp 0x167e6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x24(%rbp), %esi
callq 0x171d0
jmp 0x167e8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x167a5
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)