LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: readstore
static word
readstore(WWI *ww)
{
	if(MS_SELECT(ww->ss))
		return ww->par;
	else if(IS_FF(ww->ss))
		return ww->ffs[ww->ss & 037];
	else
		return ww->tss[ww->ss & 037];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzwl 0x16(%rdi), %eax
cmpl $0x20, %eax
jae 0x5a61
movl 0x18(%rdi), %ecx
btl %eax, %ecx
movl %eax, %eax
jae 0x5a6a
leaq (%rdi,%rax,2), %rdi
addq $0x1c, %rdi
jmp 0x5a72
addq $0x109c, %rdi           # imm = 0x109C
jmp 0x5a72
leaq (%rdi,%rax,2), %rdi
addq $0x5c, %rdi
movzwl (%rdi), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/aap[P]rx-0/ww1/mach.c
// Function: carry
static void
carry(WWI *ww)
{
	int s = ww->ac + (ww->cry<<1);
	if(s & 0200000)
		s++;
	// overflow
	ww->ac0_carry = SGN(~ww->ac) && SGN(s^ww->cry);
	ww->ac = s;
	ww->cry = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzwl 0x10a8(%rdi), %eax
movzwl 0x10aa(%rdi), %ecx
leal (%rcx,%rcx), %edx
leal (%rax,%rcx,2), %esi
btl $0x10, %esi
adcl %eax, %edx
xorl %edx, %ecx
testw %cx, %cx
sets %cl
testw %ax, %ax
setns %al
andb %cl, %al
movzbl %al, %eax
movw %ax, 0x10ae(%rdi)
movw %dx, 0x10a8(%rdi)
andw $0x0, 0x10aa(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lukexi[P]eglstreams-mini/acquire-thread-one.c
// Function: AcquireThreadMain
void* AcquireThreadMain(void* Arg) {
    egl_state* EGL = Arg;

    while (1) {
        for (int DisplayIndex = 0; DisplayIndex < EGL->DisplaysCount; DisplayIndex++) {
            egl_display* Display = &EGL->Displays[DisplayIndex];
            if (Display->PageFlipPending) {
                continue;
            }
            EGLint StreamState = EGLQueryStreamState(Display->DisplayDevice, Display->Stream);
            if (StreamState == EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR) {
                NEWTIME(StreamAcquire);
                EGLStreamAcquire(Display);
                ENDTIME(StreamAcquire);
            }
        }

    }
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x2ae5(%rip), %r14      # 0x5028
leaq 0x2af1(%rip), %r15      # 0x503b
xorl %eax, %eax
movq %rax, %r13
movslq 0x8(%rbx), %rcx
movl $0x0, %eax
cmpq %rcx, %r13
jge 0x254c
movq (%rbx), %r12
imulq $0x58, %r13, %rax
cmpb $0x0, 0x50(%r12,%rax)
jne 0x25c0
addq %rax, %r12
movq 0x30(%r12), %rdi
movq 0x40(%r12), %rsi
callq 0x3591
cmpl $0x3218, %eax           # imm = 0x3218
jne 0x25c0
xorl %eax, %eax
callq 0x41e7
movss %xmm0, 0xc(%rsp)
movq %r12, %rdi
callq 0x304a
xorl %eax, %eax
callq 0x41e7
subss 0xc(%rsp), %xmm0
mulss 0x2a55(%rip), %xmm0     # 0x5004
cvtss2sd %xmm0, %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x2050
incq %r13
movq %r13, %rax
jmp 0x254c
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/read1.c
// Function: get_arg
int get_arg(unsigned *i_ptr, unsigned type) {
	unsigned i = *i_ptr;
	uint_fast8_t c = type;

	if (type == 0) c = type = buffer[i++];
	arg_buffer[0] = 0;
	if (type == 0) return 0; /* error. */
	if (type == '[') {
		unsigned j = 0;
		for (;;) {
			c = buffer[i++];
			if (c == 0) return 0;
			if (c == ']') break;
			if (j < 31) arg_buffer[j] = c;
			++j;
		}
		if (j < 32)
			arg_buffer[j] = 0;
		else arg_buffer[31] = 0;
		*i_ptr = i;
		return j;
	}
	if (type == '(') {
		c = buffer[i++];
		if (!c) return 0;
		arg_buffer[0] = c;
		c = buffer[i++];
		if (!c) return 0;
		arg_buffer[1] = c;
		arg_buffer[2] = 0;
		*i_ptr = i;
		return 2;
	}
	arg_buffer[0] = c;
	arg_buffer[1] = 0;
	*i_ptr = i;
	return 1;
}

// Assembly:
movl (%rdi), %ecx
leaq 0x9e8f(%rip), %rdx      # 0xe3a0
testl %esi, %esi
je 0x4519
movl %esi, %eax
jmp 0x4523
movb (%rcx,%rdx), %sil
incl %ecx
movzbl %sil, %eax
movb $0x0, 0xae76(%rip)      # 0xf3a0
testl %eax, %eax
je 0x45c6
cmpl $0x28, %eax
je 0x456a
cmpl $0x5b, %eax
jne 0x459e
xorl %eax, %eax
leaq 0xae5b(%rip), %rsi      # 0xf3a0
movl %ecx, %r8d
movzbl (%r8,%rdx), %r8d
testl %r8d, %r8d
je 0x45c4
movl %eax, %r9d
cmpl $0x5d, %r8d
je 0x45b1
cmpl $0x1e, %eax
ja 0x4564
movb %r8b, (%r9,%rsi)
incl %eax
incl %ecx
jmp 0x4545
movl %ecx, %eax
movb (%rax,%rdx), %sil
xorl %eax, %eax
testb %sil, %sil
je 0x45c6
leal 0x1(%rcx), %r8d
movb %sil, 0xae1e(%rip)      # 0xf3a0
movb (%r8,%rdx), %dl
testb %dl, %dl
je 0x45c6
addl $0x2, %ecx
movb %dl, 0xae0e(%rip)       # 0xf3a1
movb $0x0, 0xae08(%rip)      # 0xf3a2
pushq $0x2
jmp 0x45ae
movb %sil, 0xadfb(%rip)      # 0xf3a0
movb $0x0, 0xadf5(%rip)      # 0xf3a1
pushq $0x1
popq %rax
jmp 0x45c1
cmpl $0x20, %eax
pushq $0x1f
popq %rdx
cmovbq %r9, %rdx
movb $0x0, (%rdx,%rsi)
incl %ecx
movl %ecx, (%rdi)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/read1.c
// Function: read_init
void read_init(FILE *fp, const char *name) {
	int i;

	type = fp ? tkTEXT : tkEOF;
	argc = 0;
	argv[0] = NULL;

	cc = '.';
	c2 = '\'';
	ec = '\\';

	ad = 'b'; 
	fi = 1;
	na = 0;
	hy = 1;
	ns = 0;

	ti = -1;
	in = prev_in = 0;
	ll = prev_ll = 78;
	ft = prev_ft = FONT_R;
	width = 78;
	line = 1;
	ignore = 0;

	render_init();


	for (i = 0; i <= so_index; ++i) free(so_entries[i].name);
	for (i = 1; i <= so_index; ++i) fclose(so_entries[i].fp);
	so_index = -1;

	if (fp) {
		so_index = 0;
		so_entries[0].fp = fp;
		so_entries[0].name = strdup(name);
		so_entries[0].line = 0;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
testq %rdi, %rdi
setne %al
movl %eax, 0x9d2a(%rip)      # 0xe310
andl $0x0, 0x9d73(%rip)      # 0xe360
andq $0x0, 0xadcb(%rip)      # 0xf3c0
movb $0x2e, 0x9d40(%rip)     # 0xe33c
movb $0x27, 0x9d3a(%rip)     # 0xe33d
andl $0x0, 0x9d5a(%rip)      # 0xe364
movb $0x5c, 0x9d2d(%rip)     # 0xe33e
andl $0x0, 0x9d50(%rip)      # 0xe368
movl $0x62, 0x9cf2(%rip)     # 0xe314
orl $-0x1, 0x9cff(%rip)     # 0xe328
pushq $0x1
popq %rax
andl $0x0, 0x9d3d(%rip)      # 0xe370
movl %eax, 0x9cdf(%rip)      # 0xe318
andl $0x0, 0x9d2c(%rip)      # 0xe36c
movl %eax, 0x9cd6(%rip)      # 0xe31c
pushq $0x4e
popq %rcx
movl %ecx, 0x9ce1(%rip)      # 0xe330
movl %ecx, 0x9cd7(%rip)      # 0xe32c
movl $0x83, %edx
movl %edx, 0x9cc4(%rip)      # 0xe324
movl %edx, 0x9cba(%rip)      # 0xe320
movl %ecx, 0x9cc8(%rip)      # 0xe334
movl %eax, 0x9cc6(%rip)      # 0xe338
andl $0x0, 0x9cfb(%rip)      # 0xe374
callq 0x6ed4
movl 0x9cbc(%rip), %ebp      # 0xe340
movslq %ebp, %r15
leaq 0xad8a(%rip), %r12      # 0xf418
xorl %r13d, %r13d
cmpq %r15, %r13
jg 0x46a8
movq (%r12), %rdi
callq 0x4040
incq %r13
addq $0x18, %r12
jmp 0x4691
pushq $0x1
popq %r15
leaq 0xad75(%rip), %r12      # 0xf428
movslq %ebp, %rax
cmpq %rax, %r15
jg 0x46d3
movq (%r12), %rdi
callq 0x4080
incq %r15
movl 0x9c73(%rip), %ebp      # 0xe340
addq $0x18, %r12
jmp 0x46b3
orl $-0x1, 0x9c66(%rip)     # 0xe340
testq %r14, %r14
je 0x4703
andl $0x0, 0x9c5a(%rip)      # 0xe340
movq %r14, 0xad23(%rip)      # 0xf410
movq %rbx, %rdi
callq 0x4190
movq %rax, 0xad1c(%rip)      # 0xf418
andl $0x0, 0xad1d(%rip)      # 0xf420
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/read1.c
// Function: man_warnc
void man_warnc(int e, const char *msg) {
	if (so_index >= 0) {
		fprintf(stderr, "%s:%d: ",
			so_entries[so_index].name,
			so_entries[so_index].line);
	}
	fputs(msg, stderr);
	if (e) {
		fputs(": ", stderr);
		fputs(strerror(e), stderr);
	}
	fputc('\n', stderr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
movslq 0x9c09(%rip), %rax      # 0xe340
testq %rax, %rax
js 0x4768
movq 0x98b5(%rip), %rcx      # 0xdff8
movq (%rcx), %rdi
imulq $0x18, %rax, %rax
leaq 0xacbf(%rip), %rcx      # 0xf410
movq 0x8(%rax,%rcx), %rdx
movl 0x10(%rax,%rcx), %ecx
leaq 0x4ea0(%rip), %rsi      # 0x9601
xorl %eax, %eax
callq 0x4100
movq 0x9889(%rip), %r15      # 0xdff8
movq (%r15), %rsi
movq %r14, %rdi
callq 0x40b0
testl %ebx, %ebx
jne 0x478e
movq (%r15), %rsi
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40d0
movq (%r15), %rsi
leaq 0x4e6e(%rip), %rdi      # 0x9606
callq 0x40b0
movl %ebx, %edi
callq 0x41a0
movq (%r15), %rsi
movq %rax, %rdi
callq 0x40b0
jmp 0x477e
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/read1.c
// Function: man_warnc1s
void man_warnc1s(int e, const char *msg, const char *s) {
	if (so_index >= 0) {
		fprintf(stderr, "%s:%d: ",
			so_entries[so_index].name,
			so_entries[so_index].line);
	}
	fprintf(stderr, msg, s);
	if (e) {
		fputs(": ", stderr);
		fputs(strerror(e), stderr);
	}
	fputc('\n', stderr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
movslq 0x9b61(%rip), %rax      # 0xe340
testq %rax, %rax
js 0x4810
movq 0x980d(%rip), %rcx      # 0xdff8
movq (%rcx), %rdi
imulq $0x18, %rax, %rax
leaq 0xac17(%rip), %rcx      # 0xf410
movq 0x8(%rax,%rcx), %rdx
movl 0x10(%rax,%rcx), %ecx
leaq 0x4df8(%rip), %rsi      # 0x9601
xorl %eax, %eax
callq 0x4100
movq 0x97e1(%rip), %r12      # 0xdff8
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4100
testl %ebx, %ebx
jne 0x4843
movq (%r12), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40d0
movq (%r12), %rsi
leaq 0x4db8(%rip), %rdi      # 0x9606
callq 0x40b0
movl %ebx, %edi
callq 0x41a0
movq (%r12), %rsi
movq %rax, %rdi
callq 0x40b0
jmp 0x482c
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/read2.c
// Function: font
static unsigned char *font(unsigned f) {
	int i,j,k;
	uint_fast8_t c;

	buffer[0] = f;

	type = tkTEXT;
	for(i = 0, j = 1; i <argc; ++i) {
		const unsigned char *cp = argv[i];
		if (i > 0) buffer[j++] = ' ';
		k = 0;
		while ((c = cp[k++])) buffer[j++] = c;
	}
	buffer[j++] = FONT_R;
	buffer[j++] = 0;
	return buffer;
}

// Assembly:
pushq %rbx
movb %dil, 0x9734(%rip)      # 0xf470
leaq 0x85cd(%rip), %rdx      # 0xe310
leaq 0x8616(%rip), %rax      # 0xe360
movl (%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movl $0x1, (%rdx)
movl $0x1, %edi
leaq 0x965b(%rip), %rsi      # 0xf3c0
leaq 0x9704(%rip), %rdx      # 0xf470
movslq %edi, %r8
cmpq %rax, %rcx
je 0x5daa
testq %rcx, %rcx
je 0x5d82
leal 0x1(%r8), %edi
movb $0x20, (%r8,%rdx)
movq (%rsi,%rcx,8), %r9
movslq %edi, %r10
xorl %r8d, %r8d
movb (%r9,%r8), %r11b
testb %r11b, %r11b
je 0x5da2
leaq (%r10,%r8), %rbx
incq %r8
movb %r11b, (%rdx,%rbx)
jmp 0x5d8c
addl %r8d, %edi
incq %rcx
jmp 0x5d6c
movw $0x83, (%r8,%rdx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/read2.c
// Function: fonts
static unsigned char *fonts(unsigned f1, unsigned f2) {
	unsigned i,j,k;
	uint_fast8_t c;

	type = tkTEXT;
	for (i = 0, j = 0; i < argc; ++i) {
		const unsigned char *cp = argv[i];
		buffer[j++] = i & 0x01 ? f2 : f1;
		k = 0;
		while ((c = cp[k++])) buffer[j++] = c;
	}

	buffer[j++] = FONT_R;
	buffer[j++] = 0;
	return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
leaq 0x8553(%rip), %rax      # 0xe310
movl $0x1, (%rax)
leaq 0x8596(%rip), %rax      # 0xe360
movl (%rax), %edx
xorl %r8d, %r8d
leaq 0x95ea(%rip), %r9       # 0xf3c0
leaq 0x9693(%rip), %rax      # 0xf470
xorl %ecx, %ecx
cmpq %rdx, %r8
je 0x5e12
movq (%r9,%r8,8), %r10
testb $0x1, %r8b
movl %esi, %ebx
cmovel %edi, %ebx
xorl %r11d, %r11d
leal (%rcx,%r11), %r14d
movb %bl, (%r14,%rax)
movl %r11d, %ebx
movb (%r10,%rbx), %bl
incl %r11d
testb %bl, %bl
jne 0x5df4
incq %r8
addl %r11d, %ecx
jmp 0x5ddf
movl %ecx, %edx
incl %ecx
movb $-0x7d, (%rdx,%rax)
movb $0x0, (%rcx,%rax)
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/read3.c
// Function: get_unit
int get_unit(const unsigned char *arg, int dv, int base) {
	double d;
	char sign = 0;
	uint_fast8_t c;
	char *cp = NULL;
	int rv;
	unsigned i;
	
	if (!arg) return dv;

	i = 0;
	while (arg[i] == ' ') ++i;
	arg += i;
	c = arg[0];
	if (!c) return dv;

	if (c == '+' || c == '-') {
		sign = c;
		++arg;
	}
	c = arg[0];
	if (!isdigit(c) && c != '.') return dv;

	errno = 0;
	d = strtod(arg, &cp);
	if (errno) return dv;

	c = *cp;
	switch (c) {
		case 'c': /* centimeter */
			d *= 94.5 / 24.0;
			break;
		case 'i': /* inch */
			d *= 10.0; /* 240.0 / 24.0; */
			break;
		case 'P': /* pica - 1/6 inch */
			d *= 10.0 / 6.0;
			break;
		case 'p': /* point - 1/72 inch */
			d *= 10.0 / 72.0;
			break;
		case 'f':
			d *= 65536.0 / 24.0;
			break;
		case 'M': /* mini em - 1/100 em */
			d  /= 100.0;
			break;

		case 'm':
		case 'n':
		case 'u':
		case 'v':
			break;
		default:
			break;
	}

	rv = (int)d;
	if (sign && base >= 0) {
		if (sign == '+') base += rv;
		else base -= rv;
		if (base < 0) return 0;
		return base;
	}
	if (sign == '-') rv = 0;

	return rv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
andq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x62f0
movl %edx, %ebx
movq %rdi, %r14
xorl %eax, %eax
movl %eax, %eax
movzbl (%r14,%rax), %r12d
cmpl $0x20, %r12d
jne 0x61f8
incl %eax
jmp 0x61e7
testl %r12d, %r12d
je 0x62f0
cmpl $0x2b, %r12d
je 0x620d
cmpl $0x2d, %r12d
jne 0x6218
addq %rax, %r14
incq %r14
movb (%r14), %r15b
jmp 0x6221
addq %rax, %r14
movl %r12d, %r15d
xorl %r12d, %r12d
callq 0x41c0
cmpb $0x2e, %r15b
je 0x6242
movq (%rax), %rax
movzbl %r15b, %ecx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
je 0x62f0
callq 0x4060
movq %rax, %r15
andl $0x0, (%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4070
cmpl $0x0, (%r15)
jne 0x62f0
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x4d, %eax
je 0x62bc
cmpl $0x50, %eax
je 0x62b2
cmpl $0x70, %eax
je 0x6294
cmpl $0x66, %eax
je 0x62a8
cmpl $0x69, %eax
je 0x629e
cmpl $0x63, %eax
jne 0x62c4
mulsd 0x3526(%rip), %xmm0     # 0x97b8
jmp 0x62c4
mulsd 0x3504(%rip), %xmm0     # 0x97a0
jmp 0x62c4
mulsd 0x350a(%rip), %xmm0     # 0x97b0
jmp 0x62c4
mulsd 0x34e8(%rip), %xmm0     # 0x9798
jmp 0x62c4
mulsd 0x34ee(%rip), %xmm0     # 0x97a8
jmp 0x62c4
divsd 0x34cc(%rip), %xmm0     # 0x9790
cvttsd2si %xmm0, %ebp
testl %ebx, %ebx
js 0x62e7
testl %r12d, %r12d
je 0x62e7
movl %ebp, %ecx
negl %ecx
cmpl $0x2b, %r12d
cmovel %ebp, %ecx
addl %ebx, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
jmp 0x62f2
xorl %eax, %eax
cmpl $0x2d, %r12d
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/chars.c
// Function: special_char
const unsigned char *special_char(const unsigned char *s) {

	unsigned begin = 0;
	unsigned end = sizeof(char_table) / sizeof(char_table[0]);

	unsigned short target = (s[0] << 8) | (s[1] << 0);

	/* binary search */
	for (;;) {
		
		unsigned mid = (begin+end)>>1;
		unsigned key = char_table[mid].key;
		if (key == target) return char_table[mid].value;

		if (key < target) {
			begin = mid + 1;
			if (begin >= end) return "";
			continue;
		}
		/* key > target  */
		end = mid;
		if (end <= begin) return "";
		continue;
		
	}
}

// Assembly:
movzwl (%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %edx
xorl %edi, %edi
movl $0x130, %esi            # imm = 0x130
leaq 0x502c(%rip), %rcx      # 0xbe70
leaq 0x2fe7(%rip), %rax      # 0x9e32
leal (%rdi,%rsi), %r8d
shrl %r8d
imulq $0x18, %r8, %r9
movzwl (%r9,%rcx), %r10d
cmpl %r10d, %edx
je 0x6e78
jbe 0x6e6f
incl %r8d
movl %r8d, %edi
cmpl %esi, %r8d
jb 0x6e4b
jmp 0x6e77
movl %r8d, %esi
cmpl %edi, %r8d
ja 0x6e4b
retq
addq %r9, %rcx
movq 0x8(%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/chars.c
// Function: special_string
const unsigned char *special_string(const unsigned char *s) {

	unsigned begin = 0;
	unsigned end = sizeof(string_table) / sizeof(string_table[0]);

	unsigned short target = (s[0] << 8) | (s[1] << 0);

	/* binary search */
	for (;;) {
		
		unsigned mid = (begin+end)>>1;
		unsigned key = string_table[mid].key;
		if (key == target) return string_table[mid].value;

		if (key < target) {
			begin = mid + 1;
			if (begin >= end) return "";
			continue;
		}
		/* key > target  */
		end = mid;
		if (end <= begin) return "";
		continue;
		
	}
}

// Assembly:
movzwl (%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %edx
xorl %edi, %edi
pushq $0x1e
popq %rsi
leaq 0x6c5a(%rip), %rcx      # 0xdaf0
leaq 0x2f95(%rip), %rax      # 0x9e32
leal (%rdi,%rsi), %r8d
shrl %r8d
imulq $0x18, %r8, %r9
movzwl (%r9,%rcx), %r10d
cmpl %r10d, %edx
je 0x6eca
jbe 0x6ec1
incl %r8d
movl %r8d, %edi
cmpl %esi, %r8d
jb 0x6e9d
jmp 0x6ec9
movl %r8d, %esi
cmpl %edi, %r8d
ja 0x6e9d
retq
addq %r9, %rcx
movq 0x8(%rcx), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/render.c
// Function: render_init
void render_init(void) {
	buffer_flip_flop = 0;
	buffer_width = 0;
	buffer_offset = 0;
	buffer_words = 0;
	buffer[0] = 0;
	prev_ftx = FONT_R;
}

// Assembly:
andl $0x0, 0x9ad5(%rip)      # 0x109b0
andl $0x0, 0x9ad2(%rip)      # 0x109b4
andl $0x0, 0x9acf(%rip)      # 0x109b8
andl $0x0, 0x9acc(%rip)      # 0x109bc
movb $0x0, 0x9ac9(%rip)      # 0x109c0
movl $0x83, 0x7443(%rip)     # 0xe344
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/render.c
// Function: set_font
void set_font(unsigned new_font) {


	if (new_font == FONT_P) new_font = prev_ft;

	if (new_font == FONT_X) {
		prev_ftx = ft;
	} else {
		prev_ft = ft;
	}

	if (ft == new_font) return;
	/* disable current font. */
	switch(ft) {
		case FONT_B: _(bold_end);
		case FONT_I: _(italic_end);
		case FONT_X: prev_ft = prev_ftx; break;
	}
	ft = new_font;
	switch(ft) {
		case FONT_B: _(bold_begin);
		case FONT_I: _(italic_begin);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x7415(%rip), %rax      # 0xe324
cmpl $0x86, %edi
jne 0x6f19
movl (%rax), %ebx
cmpl $0x87, %ebx
leaq 0x73fa(%rip), %r14      # 0xe320
movl (%r14), %ecx
leaq 0x7414(%rip), %rdx      # 0xe344
cmovneq %rax, %rdx
movl %ecx, (%rdx)
cmpl %ebx, %ecx
je 0x6fe2
cmpl $0x87, %ecx
je 0x6f8c
cmpl $0x85, %ecx
je 0x6f5f
cmpl $0x84, %ecx
jne 0x6f94
leaq 0x8d3b(%rip), %rax      # 0xfc98
jmp 0x6f66
leaq 0x8d42(%rip), %rax      # 0xfca8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x6f94
leaq 0x7403(%rip), %rax      # 0xe378
cmpl $0x0, 0x20(%rax)
jne 0x6f94
movq 0x703e(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40b0
jmp 0x6f94
movl 0x73b2(%rip), %ecx      # 0xe344
movl %ecx, (%rax)
movl %ebx, (%r14)
cmpl $0x85, %ebx
je 0x6fb0
cmpl $0x84, %ebx
jne 0x6fe2
leaq 0x8ce2(%rip), %rax      # 0xfc90
jmp 0x6fb7
leaq 0x8ce9(%rip), %rax      # 0xfca0
movq (%rax), %rdi
testq %rdi, %rdi
je 0x6fe2
leaq 0x73b2(%rip), %rax      # 0xe378
cmpl $0x0, 0x20(%rax)
jne 0x6fe2
movq 0x6fed(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/render.c
// Function: reset_font
void reset_font(void) {
	switch(ft) {
		case FONT_B: _(bold_end);
		case FONT_I: _(italic_end);
	}
	ft = prev_ft = prev_ftx = FONT_R;
}

// Assembly:
pushq %rbx
leaq 0x732e(%rip), %rbx      # 0xe320
movl (%rbx), %eax
cmpl $0x85, %eax
je 0x700b
cmpl $0x84, %eax
jne 0x7036
leaq 0x8c8f(%rip), %rax      # 0xfc98
jmp 0x7012
leaq 0x8c96(%rip), %rax      # 0xfca8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x7036
leaq 0x7357(%rip), %rax      # 0xe378
cmpl $0x0, 0x20(%rax)
jne 0x7036
movq 0x6f92(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40b0
movl $0x83, %eax
movl %eax, 0x7303(%rip)      # 0xe344
leaq 0x72dc(%rip), %rcx      # 0xe324
movl %eax, (%rcx)
movl %eax, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/render.c
// Function: set_in_ti
void set_in_ti(int new_in, int new_ti) {
	int lm;
	prev_in = in;
	in = new_in;
	ti = new_ti;
	lm = new_ti >= 0 ? new_ti : new_in;
	width = ll - lm;
}

// Assembly:
leaq 0x72b6(%rip), %rax      # 0xe36c
movl (%rax), %ecx
leaq 0x72b1(%rip), %rdx      # 0xe370
movl %ecx, (%rdx)
movl %edi, (%rax)
leaq 0x725e(%rip), %rax      # 0xe328
movl %esi, (%rax)
testl %esi, %esi
cmovsl %edi, %esi
leaq 0x7254(%rip), %rax      # 0xe32c
movl (%rax), %eax
subl %esi, %eax
leaq 0x7251(%rip), %rcx      # 0xe334
movl %eax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/render.c
// Function: set_ll
void set_ll(int new_ll) {
	int lm;
	prev_ll = ll;
	ll = new_ll;
	lm = ti >= 0 ? ti : in;
	width = ll - lm;
}

// Assembly:
leaq 0x723f(%rip), %rax      # 0xe32c
movl (%rax), %ecx
leaq 0x723a(%rip), %rdx      # 0xe330
movl %ecx, (%rdx)
movl %edi, (%rax)
leaq 0x7227(%rip), %rax      # 0xe328
movl (%rax), %eax
testl %eax, %eax
jns 0x7110
leaq 0x725e(%rip), %rax      # 0xe36c
movl (%rax), %eax
subl %eax, %edi
leaq 0x721b(%rip), %rax      # 0xe334
movl %edi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/render.c
// Function: print
unsigned print(const unsigned char *cp, int fi) {
	unsigned i;
	uint_fast8_t prev = 0;
	unsigned length = 0;

	indent();
	for (i = 0; ;++i) {
		uint_fast8_t c = cp[i];
		if (c == 0) return length;
		switch(c) {
			case FONT_R: case FONT_B: case FONT_I: case FONT_P: case FONT_X:
				set_font(c);
				break;
			case HYPHEN: case ZWSPACE: break;
			case NBSPACE: case XSPACE: fputc(' ', stdout); length++; break;
			case ' ': case '\t':
				if (fi) {
					c = ' ';
					if (prev != ' ') { fputc(' ', stdout); length++; }
				} else {
					fputc(c, stdout); length++;
				}
				break;
			default: 
				if (flags.T == FMT_ASCII) {
					if (ft == FONT_B) {
						fputc(c, stdout);
						fputc(8, stdout);
					}
					if (ft == FONT_I) {
						fputs("_\x08", stdout);
					}
				}
				fputc(c, stdout); length++;
				break;
		}
		prev = c;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
movq %rdi, %r14
callq 0x7246
xorl %r12d, %r12d
movl $0xf8, %ebx
xorl %eax, %eax
xorl %r13d, %r13d
movl %r12d, %ecx
movb (%r14,%rcx), %bpl
movzbl %bpl, %r15d
leal -0x80(%r15), %ecx
cmpl $0x8, %ecx
ja 0x7184
btl %ecx, %ebx
jae 0x7166
movl %r15d, %edi
callq 0x6f02
jmp 0x722a
pushq $0x3
popq %rax
btl %ecx, %eax
jae 0x722a
movq 0x6e47(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
pushq $0x20
popq %rdi
jmp 0x7222
cmpl $0x9, %r15d
je 0x7202
cmpl $0x20, %r15d
je 0x7202
testl %r15d, %r15d
je 0x7234
leaq 0x71d8(%rip), %rax      # 0xe378
cmpl $0x1, 0x20(%rax)
jne 0x7215
leaq 0x7173(%rip), %rax      # 0xe320
movl (%rax), %eax
cmpl $0x84, %eax
jne 0x71e3
movq 0x6e03(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
movl %r15d, %edi
callq 0x40d0
movq 0x6df1(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
pushq $0x8
popq %rdi
callq 0x40d0
leaq 0x713f(%rip), %rax      # 0xe320
movl (%rax), %eax
cmpl $0x85, %eax
jne 0x7215
movq 0x6dcf(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
leaq 0x2c35(%rip), %rdi      # 0x9e30
callq 0x40b0
jmp 0x7215
cmpl $0x0, 0x4(%rsp)
je 0x7215
movb $0x20, %bpl
cmpb $0x20, %al
je 0x722a
jmp 0x7172
movq 0x6da4(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
movl %r15d, %edi
callq 0x40d0
incl %r13d
incl %r12d
movl %ebp, %eax
jmp 0x7140
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/render.c
// Function: indent
static void indent(void) {
	int i, amt;

	if (ti >= 0) {
		amt = ti;
		ti = -1;
		width = ll - in;
	} else {
		amt = in;
	}

	if (!amt) return;

	switch(ft) {
		case FONT_B: _(bold_end);
		case FONT_I: _(italic_end);
	}
	for (i = 0; i < amt; ++i) fputc(' ', stdout);
	switch(ft) {
		case FONT_B: _(bold_begin);
		case FONT_I: _(italic_begin);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x70d4(%rip), %rax      # 0xe328
movl (%rax), %ebx
testl %ebx, %ebx
js 0x727a
orl $-0x1, (%rax)
leaq 0x70c8(%rip), %rax      # 0xe32c
movl (%rax), %eax
leaq 0x70ff(%rip), %rcx      # 0xe36c
subl (%rcx), %eax
leaq 0x70be(%rip), %rcx      # 0xe334
movl %eax, (%rcx)
jmp 0x7283
leaq 0x70eb(%rip), %rax      # 0xe36c
movl (%rax), %ebx
testl %ebx, %ebx
je 0x7341
leaq 0x708e(%rip), %r14      # 0xe320
movl (%r14), %eax
cmpl $0x85, %eax
je 0x72ac
cmpl $0x84, %eax
jne 0x72d7
leaq 0x89ee(%rip), %rax      # 0xfc98
jmp 0x72b3
leaq 0x89f5(%rip), %rax      # 0xfca8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x72d7
leaq 0x70b6(%rip), %rax      # 0xe378
cmpl $0x0, 0x20(%rax)
jne 0x72d7
movq 0x6cf1(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40b0
xorl %ebp, %ebp
testl %ebx, %ebx
cmovgl %ebx, %ebp
movq 0x6cdb(%rip), %r15      # 0xdfc0
pushq $0x20
popq %rbx
subl $0x1, %ebp
jb 0x72f9
movq (%r15), %rsi
movl %ebx, %edi
callq 0x40d0
jmp 0x72e8
movl (%r14), %eax
cmpl $0x85, %eax
je 0x7313
cmpl $0x84, %eax
jne 0x7341
leaq 0x897f(%rip), %rax      # 0xfc90
jmp 0x731a
leaq 0x8986(%rip), %rax      # 0xfca0
movq (%rax), %rdi
testq %rdi, %rdi
je 0x7341
leaq 0x704f(%rip), %rax      # 0xe378
cmpl $0x0, 0x20(%rax)
jne 0x7341
movq (%r15), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/render.c
// Function: xstrlen
unsigned xstrlen(const unsigned char *cp) {
	unsigned length = 0;
	unsigned i;
	for (i = 0; ; ++i) {
		uint_fast8_t c = cp[i];
		if (!c) return length;
		if (c <= NBSPACE) length++;
	}
}

// Assembly:
xorl %eax, %eax
xorl %ecx, %ecx
movl %ecx, %edx
movb (%rdi,%rdx), %dl
testb %dl, %dl
je 0x7363
cmpb $-0x7f, %dl
adcl $0x0, %eax
incl %ecx
jmp 0x7350
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/render.c
// Function: xstrnlen
unsigned xstrnlen(const unsigned char *cp, unsigned max) {

	unsigned length = 0;
	unsigned i;
	for (i = 0; i < max; ++i) {
		uint_fast8_t c = cp[i];
		if (!c) return length;
		if (c <= NBSPACE) length++;
	}
	return length;
}

// Assembly:
movl %esi, %ecx
xorl %edx, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x7384
movb (%rdi,%rdx), %sil
testb %sil, %sil
je 0x7384
cmpb $-0x7f, %sil
adcl $0x0, %eax
incq %rdx
jmp 0x736a
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/render.c
// Function: append_font
void append_font(unsigned font) {
	/* todo - check if buffer is overflowing */

	/* if there is trailing WS, this inserts a FONT_X token before the whitespace. */
	unsigned k;
	unsigned xfont = 0;

	k = buffer_offset;
	if (k == 0) {
		buffer[0] = font;
		buffer_offset++;
		return;
	}

	while (k > 0) {
		uint_fast8_t c = buffer[--k];
		if (c == ' ' || c == XSPACE) {
			buffer[k+1] = c;
			xfont = 1;
		} else break;
	}
	if (xfont) {
		buffer[k+1] = FONT_X;
		++buffer_offset;
	}
	buffer[buffer_offset++] = font;
}

// Assembly:
movl 0x962d(%rip), %eax      # 0x109b8
testq %rax, %rax
je 0x73ea
movb $0x1, %sil
pushq $0x1
popq %r8
leaq 0x9622(%rip), %rcx      # 0x109c0
movq %rax, %rdx
movq %rax, %r9
subq $0x1, %r9
jb 0x73ca
movzbl -0x1(%rdx,%rcx), %r10d
cmpl $0x81, %r10d
je 0x73bf
cmpl $0x20, %r10d
jne 0x73cd
movb %r10b, (%rdx,%rcx)
xorl %esi, %esi
movq %r9, %rdx
jmp 0x73a4
movq %r8, %rdx
testb $0x1, %sil
jne 0x73db
movl %edx, %edx
movb $-0x79, (%rdx,%rcx)
incl %eax
movl %eax, %edx
incl %edx
movl %edx, 0x95d3(%rip)      # 0x109b8
movb %dil, (%rax,%rcx)
retq
movb %dil, 0x95cf(%rip)      # 0x109c0
movl $0x1, 0x95bd(%rip)      # 0x109b8
retq
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/render.c
// Function: set_tag
void set_tag(const unsigned char *cp, unsigned IP) {
	/* set the tag for IP/TP */
	unsigned n;

	/* assumes buffer has been flushed */
	/* set_in_ti(LM + IP, LM); */

	n = xstrlen(cp);
	if (n >= width || n >= IP) { 
		append(cp);
		flush(0);
	} else {
		uint_fast8_t c;
		unsigned i;
		for (i = 0; ; ++i) {
			c = cp[i];
			if (c == 0) break;
			if (c == ' ' || c == '\t') c = NBSPACE;
			buffer[buffer_offset++] = c;
			if (c <= NBSPACE) buffer_width++;
		}
		buffer[buffer_offset] = 0;

		while(buffer_width < IP) {
			buffer[buffer_offset++] = NBSPACE;
			buffer_width++;
		}
		buffer[buffer_offset] = 0;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x734c
cmpl %ebx, %eax
jae 0x79bf
leaq 0x69d4(%rip), %rcx      # 0xe334
cmpl (%rcx), %eax
jae 0x79bf
movl 0x904e(%rip), %eax      # 0x109b8
xorl %esi, %esi
movl 0x9042(%rip), %edx      # 0x109b4
movl $0x80, %edi
leaq 0x9042(%rip), %rcx      # 0x109c0
movl %esi, %r8d
movb (%r14,%r8), %r9b
movl %eax, %r8d
testb %r9b, %r9b
je 0x79d5
cmpb $0x9, %r9b
movzbl %r9b, %r10d
cmovel %edi, %r10d
cmpb $0x20, %r9b
cmovel %edi, %r10d
incl %eax
movl %eax, 0x900f(%rip)      # 0x109b8
movb %r10b, (%r8,%rcx)
cmpb $-0x80, %r10b
ja 0x79bb
incl %edx
movl %edx, 0x8ff9(%rip)      # 0x109b4
incl %esi
jmp 0x797e
movq %r14, %rdi
callq 0x73fc
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7692
movb $0x0, (%r8,%rcx)
movl %eax, %esi
cmpl %ebx, %edx
jae 0x79f6
incl %eax
movl %eax, 0x8fd0(%rip)      # 0x109b8
movb $-0x80, (%rsi,%rcx)
incl %edx
movl %edx, 0x8fc0(%rip)      # 0x109b4
jmp 0x79da
movb $0x0, (%rsi,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ksherlock[P]nroff_man/tbl.c
// Function: num_width
unsigned num_width(const char *cp, unsigned n, int *offset) {

	int zwsp = -1;
	int dig = -1;
	int dot = -1;
	unsigned l = 0;
	int st = 0;
	for (unsigned i = 0; i < n; ++i) {
		unsigned c = cp[i];
		if (c == ZWSPACE && zwsp < 0) zwsp = l+1;
		if (c > XSPACE) continue;
		++l;

		st <<= 2;
		if (c == '.') st |= 0b01;
		else if (isdigit(c)) {
			dig = l+1;
			st |= 0b11;
		}
		st &= 0b1111;
		if (st == 0b1101) dot = l;
		if (st == 0b0111) dot = l-1;
	}
	if (dot < 0) dot = dig;
	if (zwsp >= 0) dot = zwsp;
	*offset = dot;
	return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, %r12
movl %esi, %ecx
xorl %r13d, %r13d
pushq $-0x1
popq %rbp
movl %ebp, 0x4(%rsp)
xorl %r15d, %r15d
xorl %ebx, %ebx
movq %rcx, 0x8(%rsp)
cmpq %r13, %rcx
je 0x7a89
movsbq (%r12,%r13), %r14
testq %r14, %r14
js 0x7a84
shll $0x2, %ebx
cmpb $0x2e, %r14b
jne 0x7a4d
orl $0x1, %ebx
jmp 0x7a6d
callq 0x41c0
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r14,2)
je 0x7a68
leal 0x2(%r15), %eax
movl %eax, 0x4(%rsp)
orl $0x3, %ebx
movq 0x8(%rsp), %rcx
leal 0x1(%r15), %eax
andl $0xf, %ebx
cmpl $0xd, %ebx
cmovel %eax, %ebp
cmpl $0x7, %ebx
cmovel %r15d, %ebp
movl %eax, %r15d
incq %r13
jmp 0x7a30
testl %ebp, %ebp
movl 0x4(%rsp), %ecx
cmovnsl %ebp, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/liuhaotian[P]xmppsh/libstrophe/examples/basic.c
// Function: conn_handler
void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
                  const int error, xmpp_stream_error_t * const stream_error,
                  void * const userdata)
{
    xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;

    if (status == XMPP_CONN_CONNECT) {
        fprintf(stderr, "DEBUG: connected\n");
        xmpp_disconnect(conn);
    }
    else {
        fprintf(stderr, "DEBUG: disconnected\n");
        xmpp_stop(ctx);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0xeb71(%rip), %rax      # 0x10fe8
movq (%rax), %rcx
testl %esi, %esi
jne 0x24a2
movq %rdi, %r14
leaq 0x9b7c(%rip), %rdi      # 0xc004
pushq $0x11
popq %rsi
pushq $0x1
popq %rdx
callq 0x2300
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x44f6
movq %r8, %rbx
leaq 0x9b6a(%rip), %rdi      # 0xc016
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
callq 0x2300
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x51ad
// File: /workspace/github_c_makefile_star2_O2/liuhaotian[P]xmppsh/libstrophe/examples/basic.c
// Function: main
int main(int argc, char **argv)
{
    xmpp_ctx_t *ctx;
    xmpp_conn_t *conn;
    xmpp_log_t *log;
    char *jid, *pass, *host;

    /* take a jid and password on the command line */
    if (argc < 3 || argc > 4) {
        fprintf(stderr, "Usage: basic <jid> <pass> [<host>]\n\n");
        return 1;
    }

    jid = argv[1];
    pass = argv[2];
    host = NULL;

    if (argc == 4)
        host = argv[3];

    /* init library */
    xmpp_initialize();

    /* create a context */
    log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG); /* pass NULL instead to silence output */
    ctx = xmpp_ctx_new(NULL, log);

    /* create a connection */
    conn = xmpp_conn_new(ctx);

    /* setup authentication information */
    xmpp_conn_set_jid(conn, jid);
    xmpp_conn_set_pass(conn, pass);

    /* initiate connection */
    xmpp_connect_client(conn, host, 0, conn_handler, ctx);

    /* enter the event loop -
       our connect handler will trigger an exit */
    xmpp_run(ctx);

    /* release our connection and context */
    xmpp_conn_release(conn);
    xmpp_ctx_free(ctx);

    /* final shutdown of the library */
    xmpp_shutdown();

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leal -0x5(%rdi), %eax
cmpl $-0x3, %eax
jbe 0x2574
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %r14
xorl %ebx, %ebx
cmpl $0x4, %edi
jne 0x24f2
movq 0x18(%rsi), %r15
jmp 0x24f5
xorl %r15d, %r15d
callq 0x47f8
xorl %edi, %edi
callq 0x4850
xorl %edi, %edi
movq %rax, %rsi
callq 0x4bb1
movq %rax, %r13
movq %rax, %rdi
callq 0x3c24
movq %rax, %rbp
movq %rax, %rdi
movq %r12, %rsi
callq 0x421b
movq %rbp, %rdi
movq %r14, %rsi
callq 0x4257
leaq -0xca(%rip), %rcx       # 0x246c
movq %rbp, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r13, %r8
callq 0x4296
movq %r13, %rdi
callq 0x515d
movq %rbp, %rdi
callq 0x3ff0
movq %r13, %rdi
callq 0x4c10
callq 0x4804
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xea6d(%rip), %rax      # 0x10fe8
movq (%rax), %rcx
leaq 0x9aa6(%rip), %rdi      # 0xc02b
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x2300
pushq $0x1
popq %rbx
jmp 0x2563
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/acorn128v2/ref/encrypt.c
// Function: Encrypt_StateUpdate128_1bit
void Encrypt_StateUpdate128_1bit(unsigned char *state, unsigned char plaintextbit, unsigned char *ciphertextbit, unsigned char *ks, unsigned char ca, unsigned char cb)
{
    unsigned int  j;
    unsigned char f;

    state[289] ^= state[235] ^ state[230];
    state[230] ^= state[196] ^ state[193];
    state[193] ^= state[160] ^ state[154];
    state[154] ^= state[111] ^ state[107];
    state[107] ^= state[66]  ^ state[61];
    state[61]  ^= state[23]  ^ state[0];

    f  = FBK128(state, ks, ca, cb);

    for (j = 0; j <= 291; j++) state[j] = state[j+1];
    state[292] = f ^ plaintextbit;
    *ciphertextbit = *ks ^ plaintextbit;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movb 0xeb(%rdi), %al
movb 0xe6(%rdi), %cl
xorb 0x121(%rdi), %al
xorb %cl, %al
movb %al, 0x121(%rdi)
movb 0xc1(%rdi), %al
xorb 0xc4(%rdi), %cl
xorb %al, %cl
movb %cl, 0xe6(%rdi)
xorb 0xa0(%rdi), %al
movb 0x9a(%rdi), %cl
xorb %cl, %al
movb %al, 0xc1(%rdi)
movb 0x6b(%rdi), %al
xorb 0x6f(%rdi), %cl
xorb %al, %cl
movb %cl, 0x9a(%rdi)
movb 0x17(%rdi), %cl
movb 0x3d(%rdi), %dl
xorb 0x42(%rdi), %al
xorb %dl, %al
movb %al, 0x6b(%rdi)
xorb (%rdi), %cl
xorb %dl, %cl
movb %cl, 0x3d(%rdi)
movq %r14, %rsi
movl %r8d, %edx
movl %r9d, %ecx
callq 0x1070
pushq $0x1
popq %rcx
cmpq $0x125, %rcx            # imm = 0x125
je 0x12f4
movb (%r15,%rcx), %dl
movb %dl, -0x1(%r15,%rcx)
incq %rcx
jmp 0x12dd
xorb %bpl, %al
movb %al, 0x124(%r15)
xorb (%r14), %bpl
movb %bpl, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/acorn128v2/ref/encrypt.c
// Function: Decrypt_StateUpdate128_1bit
void Decrypt_StateUpdate128_1bit(unsigned char *state, unsigned char *plaintextbit, unsigned char ciphertextbit, unsigned char *ks, unsigned char ca, unsigned char cb)
{
    unsigned int  j;
    unsigned char f;

    state[289] ^= state[235] ^ state[230];
    state[230] ^= state[196] ^ state[193];
    state[193] ^= state[160] ^ state[154];
    state[154] ^= state[111] ^ state[107];
    state[107] ^= state[66]  ^ state[61];
    state[61]  ^= state[23]  ^ state[0];

    f = FBK128(state, ks, ca, cb);

    for (j = 0; j <= 291; j++) state[j] = state[j+1];
    *plaintextbit = *ks ^ ciphertextbit;
    state[292] = f ^ *plaintextbit;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movb 0xeb(%rdi), %al
movb 0xe6(%rdi), %cl
xorb 0x121(%rdi), %al
xorb %cl, %al
movb %al, 0x121(%rdi)
movb 0xc1(%rdi), %al
xorb 0xc4(%rdi), %cl
xorb %al, %cl
movb %cl, 0xe6(%rdi)
xorb 0xa0(%rdi), %al
movb 0x9a(%rdi), %cl
xorb %cl, %al
movb %al, 0xc1(%rdi)
movb 0x6b(%rdi), %al
xorb 0x6f(%rdi), %cl
xorb %al, %cl
movb %cl, 0x9a(%rdi)
movb 0x17(%rdi), %cl
movb 0x3d(%rdi), %dl
xorb 0x42(%rdi), %al
xorb %dl, %al
movb %al, 0x6b(%rdi)
xorb (%rdi), %cl
xorb %dl, %cl
movb %cl, 0x3d(%rdi)
movq %r15, %rsi
movl %r8d, %edx
movl %r9d, %ecx
callq 0x1070
pushq $0x1
popq %rcx
cmpq $0x125, %rcx            # imm = 0x125
je 0x13af
movb (%r14,%rcx), %dl
movb %dl, -0x1(%r14,%rcx)
incq %rcx
jmp 0x1398
xorb (%r15), %bl
movb %bl, (%r12)
xorb %al, %bl
movb %bl, 0x124(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/acorn128v2/ref/encrypt.c
// Function: acorn128_enc_onebyte
void acorn128_enc_onebyte(unsigned char *state, unsigned char plaintextbyte,
       unsigned char *ciphertextbyte, unsigned char *ksbyte, unsigned char cabyte, unsigned char cbbyte)
{
    unsigned char i,t[4];
    unsigned char plaintextbit,ciphertextbit,kstem,ca,cb;

    *ciphertextbyte = 0;
    kstem = 0;
    *ksbyte = 0;
    for (i = 0; i < 8; i++)
    {
        ca = (cabyte >> i) & 1;
        cb = (cbbyte >> i) & 1;
        plaintextbit = (plaintextbyte >> i) & 1;
        Encrypt_StateUpdate128_1bit(state, plaintextbit, &ciphertextbit, &kstem, ca, cb);
        *ciphertextbyte |= (ciphertextbit << i);
        *ksbyte |= (kstem << i);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
xorl %ebx, %ebx
movb %bl, (%rdx)
leaq 0x2(%rsp), %rax
movb %bl, (%rax)
movb %bl, (%rcx)
cmpl $0x8, %ebx
je 0x1448
shrxl %ebx, %ebp, %r8d
shrxl %ebx, 0x4(%rsp), %r9d
shrxl %ebx, %r12d, %esi
andl $0x1, %esi
andl $0x1, %r8d
andl $0x1, %r9d
movq %r13, %rdi
leaq 0x3(%rsp), %rdx
leaq 0x2(%rsp), %rcx
callq 0x10a0
movzbl 0x3(%rsp), %eax
shlxl %ebx, %eax, %eax
orb %al, (%r15)
movzbl 0x2(%rsp), %eax
shlxl %ebx, %eax, %eax
orb %al, (%r14)
incl %ebx
jmp 0x13f7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/acorn128v2/ref/encrypt.c
// Function: acorn128_dec_onebyte
void acorn128_dec_onebyte(unsigned char *state, unsigned char *plaintextbyte,
       unsigned char ciphertextbyte, unsigned char *ksbyte, unsigned char cabyte, unsigned char cbbyte)
{
    unsigned char i;
    unsigned char plaintextbit,ciphertextbit, ks,ca,cb;

    *plaintextbyte = 0;
    for  (i = 0; i < 8; i++)
    {
        ca = (cabyte >> i) & 1;
        cb = (cbbyte >> i) & 1;
        ciphertextbit = (ciphertextbyte >> i) & 1;
        Decrypt_StateUpdate128_1bit(state, &plaintextbit, ciphertextbit, &ks, ca, cb);
        *plaintextbyte |= (plaintextbit << i);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movb $0x0, (%rsi)
xorl %r13d, %r13d
cmpl $0x8, %r13d
je 0x14bb
shrxl %r13d, %ebp, %r8d
shrxl %r13d, %ebx, %r9d
shrxl %r13d, %r14d, %edx
andl $0x1, %edx
andl $0x1, %r8d
andl $0x1, %r9d
movq %r12, %rdi
leaq 0x6(%rsp), %rsi
leaq 0x7(%rsp), %rcx
callq 0x1080
movzbl 0x6(%rsp), %eax
shlxl %r13d, %eax, %eax
orb %al, (%r15)
incl %r13d
jmp 0x1477
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/acorn128v2/ref/encrypt.c
// Function: acorn128_initialization
void acorn128_initialization(const unsigned char *key, const unsigned char *iv, unsigned char *state)
{
        int i,j;
        unsigned char m[293], ks, tem;

        //initialize the state to 0
        for (j = 0; j <= 292; j++) state[j] = 0;

        //set the value of m
        for (j = 0; j <=  15;   j++)   m[j] = key[j];
        for (j = 16; j <= 31;   j++)   m[j] = iv[j - 16];
        for (j = 32; j <= 223;  j++)   m[j] = key[j & 0xf];
        m[32] ^= 1;

        //run the cipher for 1792 steps
        for (i = 0; i < 224; i++)
        {
             acorn128_enc_onebyte(state, m[i], &tem, &ks, 0xff, 0xff);
        }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdx, %rbx
xorl %eax, %eax
cmpq $0x125, %rax            # imm = 0x125
je 0x14ee
movb $0x0, (%rbx,%rax)
incq %rax
jmp 0x14dd
xorl %eax, %eax
cmpq $0x10, %rax
je 0x1502
movb (%rdi,%rax), %cl
movb %cl, 0x10(%rsp,%rax)
incq %rax
jmp 0x14f0
pushq $0x10
popq %rax
cmpq $0x20, %rax
je 0x1518
movb -0x10(%rsi,%rax), %cl
movb %cl, 0x10(%rsp,%rax)
incq %rax
jmp 0x1505
pushq $0x20
popq %rax
cmpq $0xe0, %rax
je 0x1534
movl %eax, %ecx
andl $0xf, %ecx
movb (%rdi,%rcx), %cl
movb %cl, 0x10(%rsp,%rax)
incq %rax
jmp 0x151b
xorb $0x1, 0x30(%rsp)
xorl %r12d, %r12d
leaq 0xe(%rsp), %r14
leaq 0xf(%rsp), %r15
cmpq $0xe0, %r12
je 0x1574
movzbl 0x10(%rsp,%r12), %esi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
movl $0xff, %r8d
movl $0xff, %r9d
callq 0x10d0
incq %r12
jmp 0x1546
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/acorn128v2/ref/encrypt.c
// Function: acorn128_tag_generation
void acorn128_tag_generation(unsigned long long msglen, unsigned long long adlen, unsigned char maclen, unsigned char *mac, unsigned char *state)
{
    int i;
    unsigned char plaintextbyte  = 0;
    unsigned char ciphertextbyte = 0;
    unsigned char ksbyte = 0;

    for (i = 0; i < 768/8; i++)
    {
        acorn128_enc_onebyte(state, plaintextbyte, &ciphertextbyte, &ksbyte, 0xff, 0xff);
        if ( i >= (768/8 - 16) ) {mac[i-(768/8-16)] = ksbyte; }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %r14
xorl %r13d, %r13d
leaq 0xf(%rsp), %r15
movb %r13b, (%r15)
leaq 0xe(%rsp), %r12
movb %r13b, (%r12)
cmpq $0x60, %r13
je 0x15e0
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
movl $0xff, %r8d
movl $0xff, %r9d
callq 0x10d0
cmpq $0x50, %r13
jb 0x15db
movb 0xe(%rsp), %al
movb %al, -0x50(%r14,%r13)
incq %r13
jmp 0x15aa
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/src/basic_block.cpp
// Function: BasicBlock::BasicBlock(unsigned long long, unsigned long long, Function*)
BasicBlock::BasicBlock(ADDR eip, ADDR vAddr, Function *func):
    hashNext(NULL), func(func), disasmed(false), disasm_pending(false)
    , visited(false)
{
    DISASM MyDisasm;
    memset(&MyDisasm, 0, sizeof(DISASM));
    MyDisasm.EIP = eip;
    MyDisasm.VirtualAddr = vAddr;
    MyDisasm.Archi = 64;
    MyDisasm.Options = ATSyntax|PrefixedNumeral|Tabulation;
    insts.push_back(MyDisasm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rcx, 0x50(%rdi)
andw $0x0, 0x58(%rdi)
movq %rdx, %r14
movq %rsi, %r15
movb $0x0, 0x5a(%rdi)
leaq 0x18(%rsp), %r12
movl $0x27d, %edx            # imm = 0x27D
movq %r12, %rdi
xorl %esi, %esi
callq 0x80e0
movq %r15, -0x10(%r12)
movq %r14, -0x8(%r12)
movl $0x40, 0x44(%r12)
movq $0x10401, 0x48(%r12)    # imm = 0x10401
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x88f4
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x30(%rbx), %rdi
leaq 0x18(%rbx), %r15
callq 0x89d6
movq %r15, %rdi
callq 0x89d6
movq %rbx, %rdi
callq 0x8996
movq %r14, %rdi
callq 0x82a0
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/src/basic_block.cpp
// Function: BasicBlock::toString(char*, int) const
char *BasicBlock::toString(char *buf, int size) const
{
    snprintf(buf, size, "\t\t\t0x%llx(0x%llx) %ld instructions", (ADDR)this, getFirstInstAddr(), insts.size());

    if (!successors.empty()) {
        snprintf(buf+strlen(buf), size-strlen(buf), "\n\t\t\tsucc{");
        for (ConstBBPtrIter iter = successors.begin(); iter != successors.end(); iter++) {
            snprintf(buf+strlen(buf), size-strlen(buf), "0x%llx(0x%llx), ", (ADDR)(*iter), (*iter)->getFirstInstAddr());
        }
        snprintf(buf+strlen(buf)-2, size-strlen(buf)+2, "}");
    }

    if (!predecessors.empty()) {
        snprintf(buf+strlen(buf), size-strlen(buf), "\n\t\t\tpred{");
        for (ConstBBPtrIter iter = predecessors.begin(); iter != predecessors.end(); iter++) {
            snprintf(buf+strlen(buf), size-strlen(buf), "0x%llx(0x%llx), ", (ADDR)(*iter), (*iter)->getFirstInstAddr());
        }
        snprintf(buf+strlen(buf)-2, size-strlen(buf)+2, "}");
    }
    return buf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movslq %edx, %r14
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
movq 0x8(%rcx), %r8
subq %rcx, %rax
movl $0x28d, %ecx            # imm = 0x28D
cqto
idivq %rcx
leaq 0x219bd(%rip), %rdx     # 0x2a0c4
movq %rsi, %rdi
movq %r14, %rsi
movq %r15, %rcx
movq %rax, %r9
xorl %eax, %eax
callq 0x8260
movq 0x18(%r15), %rax
cmpq 0x20(%r15), %rax
je 0x87a1
movq %rbx, %rdi
callq 0x8090
leaq (%rbx,%rax), %rdi
movq %r14, %rsi
subq %rax, %rsi
leaq 0x219aa(%rip), %rdx     # 0x2a0e7
xorl %eax, %eax
callq 0x8260
movq 0x18(%r15), %r13
leaq 0x219a2(%rip), %r12     # 0x2a0f1
movq 0x20(%r15), %rbp
movq %rbx, %rdi
callq 0x8090
leaq (%rbx,%rax), %rdi
cmpq %rbp, %r13
je 0x8785
movq %r14, %rsi
subq %rax, %rsi
movq (%r13), %rcx
movq (%rcx), %rax
movq 0x8(%rax), %r8
movq %r12, %rdx
xorl %eax, %eax
callq 0x8260
addq $0x8, %r13
jmp 0x874f
addq $-0x2, %rdi
movq %r14, %rsi
subq %rax, %rsi
addq $0x2, %rsi
leaq 0x21968(%rip), %rdx     # 0x2a102
xorl %eax, %eax
callq 0x8260
movq 0x30(%r15), %rax
cmpq 0x38(%r15), %rax
je 0x8828
movq %rbx, %rdi
callq 0x8090
leaq (%rbx,%rax), %rdi
movq %r14, %rsi
subq %rax, %rsi
leaq 0x21940(%rip), %rdx     # 0x2a104
xorl %eax, %eax
callq 0x8260
movq 0x30(%r15), %r13
leaq 0x2191b(%rip), %r12     # 0x2a0f1
movq 0x38(%r15), %rbp
movq %rbx, %rdi
callq 0x8090
leaq (%rbx,%rax), %rdi
cmpq %rbp, %r13
je 0x880c
movq %r14, %rsi
subq %rax, %rsi
movq (%r13), %rcx
movq (%rcx), %rax
movq 0x8(%rax), %r8
movq %r12, %rdx
xorl %eax, %eax
callq 0x8260
addq $0x8, %r13
jmp 0x87d6
addq $-0x2, %rdi
subq %rax, %r14
addq $0x2, %r14
leaq 0x218e4(%rip), %rdx     # 0x2a102
movq %r14, %rsi
xorl %eax, %eax
callq 0x8260
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/buptlxb[P]xRay/src/basic_block.cpp
// Function: BasicBlock::dump() const
void BasicBlock::dump() const
{
    dumpBiref();
    for (ConstDisasmIter iter = insts.begin(); iter != insts.end(); iter++) {
    printf("\t\t\t0x%.8lx\t%s\n", iter->VirtualAddr, (char *)&iter->CompleteInstr);
    }
    puts("");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x883a
movq (%rbx), %r15
leaq 0x21893(%rip), %r14     # 0x2a10e
cmpq 0x8(%rbx), %r15
je 0x889c
movq 0x8(%r15), %rsi
leaq 0x14(%r15), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x8030
addq $0x28d, %r15            # imm = 0x28D
jmp 0x887b
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x8200
nop