LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_compatible_va_list_type
static bool _is_compatible_va_list_type(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

	if (_get_type_by_type_node(ctx, target) == FE_TYPE_VA_LIST
			&& _get_type_by_type_node(ctx, source) == FE_TYPE_VA_LIST) {
		return true;
	} else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5f6b4
jmp 0x5f6d3
leaq 0x1ce9b(%rip), %rdi     # 0x7c556
leaq 0x1eb88(%rip), %rsi     # 0x7e24a
movl $0x2f5, %edx            # imm = 0x2F5
leaq 0x21cc4(%rip), %rcx     # 0x81392
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5f6dc
jmp 0x5f6fb
leaq 0x1c03f(%rip), %rdi     # 0x7b722
leaq 0x1eb60(%rip), %rsi     # 0x7e24a
movl $0x2f6, %edx            # imm = 0x2F6
leaq 0x21c9c(%rip), %rcx     # 0x81392
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x5f704
jmp 0x5f723
leaq 0x11e86(%rip), %rdi     # 0x71591
leaq 0x1eb38(%rip), %rsi     # 0x7e24a
movl $0x2f7, %edx            # imm = 0x2F7
leaq 0x21c74(%rip), %rcx     # 0x81392
callq 0x30a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4d750
movzbl %al, %eax
cmpl $0xc, %eax
jne 0x5f753
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d750
movzbl %al, %eax
cmpl $0xc, %eax
jne 0x5f753
movb $0x1, -0x1(%rbp)
jmp 0x5f757
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_compatible_array_type_dims
static bool _is_compatible_array_type_dims(
	ParserContext *ctx,
	ParserASTNode *target_dims,
	ParserASTNode *source_dims
) {
	assert(ctx);
	assert(target_dims);
	assert(source_dims);

	if (target_dims->nchilds != source_dims->nchilds) {
		return false;
	}

	for (int32_t i = 0; i < target_dims->nchilds; i++) {
		ParserASTNode *target_dim = target_dims->childs[i];
		ParserASTNode *source_dim = source_dims->childs[i];
		if (fe_parser_get_uint_val(ctx, target_dim) != fe_parser_get_uint_val(ctx, source_dim)) {
			return false;
		}
	}
	
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5f78d
jmp 0x5f7ac
leaq 0x1cdc2(%rip), %rdi     # 0x7c556
leaq 0x1eaaf(%rip), %rsi     # 0x7e24a
movl $0x265, %edx            # imm = 0x265
leaq 0x21b7b(%rip), %rcx     # 0x81322
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5f7b5
jmp 0x5f7d4
leaq 0x21bbe(%rip), %rdi     # 0x8137a
leaq 0x1ea87(%rip), %rsi     # 0x7e24a
movl $0x266, %edx            # imm = 0x266
leaq 0x21b53(%rip), %rcx     # 0x81322
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x5f7dd
jmp 0x5f7fc
leaq 0x21ba2(%rip), %rdi     # 0x81386
leaq 0x1ea5f(%rip), %rsi     # 0x7e24a
movl $0x267, %edx            # imm = 0x267
leaq 0x21b2b(%rip), %rcx     # 0x81322
callq 0x30a0
movq -0x18(%rbp), %rax
movl 0x44(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x44(%rcx), %eax
je 0x5f812
movb $0x0, -0x1(%rbp)
jmp 0x5f88e
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x5f88a
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x429f0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x429f0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0x5f87d
movb $0x0, -0x1(%rbp)
jmp 0x5f88e
jmp 0x5f87f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5f819
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/oreparaz[P]dudect/examples/aes32/dut_aes32.c
// Function: do_one_computation
uint8_t do_one_computation(uint8_t *data) {
  uint8_t in[16] = {0};
  uint8_t out[16] = {0};
  uint8_t ret = 0;

  memcpy(in, data, 16);

  rijndaelEncrypt(rk, 10, in, out);

  ret ^= out[0];
  /* return some computation output to try to tame a clever optimizing compiler */
  return ret;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1080
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1080
movb $0x0, 0xf(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0xa399(%rip), %rdi      # 0xc0a0
movl $0xa, %esi
callq 0x2d40
movzbl 0x10(%rsp), %ecx
movzbl 0xf(%rsp), %eax
xorl %ecx, %eax
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/tools/bdf.h
// Function: load_table
void load_table(char *path, enum encode_t encode)
{
	int i;
	char buf[BUFSIZE], *cp;
	FILE *fp;
	uint32_t from, to;

	fp = efopen(path, "r");

	for (i = 0; i < UCS2_CHARS; i++) {
		if (encode == ISO10646)
			convert_table[i] = i;
		else
			convert_table[i] = -1;
	}

	while (fgets(buf, BUFSIZE, fp) != NULL) {
		if (strlen(buf) == 0 || buf[0] == '#')
			continue;

		if ((cp = strchr(buf, '\n')) != NULL)
			*cp = '\0';

		sscanf(buf, "%X %X", (unsigned int *) &from, (unsigned int *) &to);
		convert_table[from] = to;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1913(%rip), %rsi      # 0x3010
callq 0x1360
movq %rax, -0x420(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x10000, -0x10(%rbp)   # imm = 0x10000
jge 0x1751
cmpl $0x4, -0xc(%rbp)
jne 0x1732
movl -0x10(%rbp), %edx
movslq -0x10(%rbp), %rcx
leaq 0x39f3(%rip), %rax      # 0x5120
movl %edx, (%rax,%rcx,4)
jmp 0x1744
movslq -0x10(%rbp), %rcx
leaq 0x39e3(%rip), %rax      # 0x5120
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x1746
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1710
jmp 0x1753
leaq -0x410(%rbp), %rdi
movq -0x420(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x10c0
cmpq $0x0, %rax
je 0x17fd
leaq -0x410(%rbp), %rdi
callq 0x1090
cmpq $0x0, %rax
je 0x1793
movsbl -0x410(%rbp), %eax
cmpl $0x23, %eax
jne 0x1795
jmp 0x1753
leaq -0x410(%rbp), %rdi
movl $0xa, %esi
callq 0x10a0
movq %rax, -0x418(%rbp)
cmpq $0x0, %rax
je 0x17bd
movq -0x418(%rbp), %rax
movb $0x0, (%rax)
leaq -0x410(%rbp), %rdi
leaq 0x1905(%rip), %rsi      # 0x30d0
leaq -0x424(%rbp), %rdx
leaq -0x428(%rbp), %rcx
movb $0x0, %al
callq 0x1100
movl -0x428(%rbp), %edx
movl -0x424(%rbp), %eax
movl %eax, %ecx
leaq 0x392b(%rip), %rax      # 0x5120
movl %edx, (%rax,%rcx,4)
jmp 0x1753
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/tools/bdf.h
// Function: read_char
int read_char(char *buf, struct bdf_char_t *bdf_char)
{
	if (pre_match(buf, "BBX "))
		sscanf(buf + strlen("BBX "), "%d %d %d %d",
			&bdf_char->bbw, &bdf_char->bbh, &bdf_char->bbx, &bdf_char->bby);
	else if (pre_match(buf, "DWIDTH "))
		bdf_char->dwidth = atoi(buf + strlen("DWIDTH "));
	else if (pre_match(buf, "ENCODING ")) {
		bdf_char->encoding = atoi(buf + strlen("ENCODING "));
		//logging(DEBUG, "reading char:%d\n", bdf_char->encoding);
	}
	else if (pre_match(buf, "BITMAP")) {
		return BDF_BITMAP;
	}

	return BDF_CHAR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1659(%rip), %rsi      # 0x31b4
callq 0x14d0
cmpl $0x0, %eax
je 0x1b99
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rcx
addq $0x4, %rcx
movq -0x18(%rbp), %r8
addq $0x8, %r8
movq -0x18(%rbp), %r9
addq $0xc, %r9
leaq 0x1557(%rip), %rsi      # 0x30e7
movb $0x0, %al
callq 0x1100
jmp 0x1c17
movq -0x10(%rbp), %rdi
leaq 0x1615(%rip), %rsi      # 0x31b9
callq 0x14d0
cmpl $0x0, %eax
je 0x1bc6
movq -0x10(%rbp), %rdi
addq $0x7, %rdi
callq 0x1150
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x1c15
movq -0x10(%rbp), %rdi
leaq 0x15f0(%rip), %rsi      # 0x31c1
callq 0x14d0
cmpl $0x0, %eax
je 0x1bf3
movq -0x10(%rbp), %rdi
addq $0x9, %rdi
callq 0x1150
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0x1c13
movq -0x10(%rbp), %rdi
leaq 0x15cd(%rip), %rsi      # 0x31cb
callq 0x14d0
cmpl $0x0, %eax
je 0x1c11
movl $0x2, -0x4(%rbp)
jmp 0x1c1e
jmp 0x1c13
jmp 0x1c15
jmp 0x1c17
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/tools/bdf.h
// Function: load_bdf_glyph
bool load_bdf_glyph(struct glyph_list_t **glist_head, struct glyph_t *default_glyph, char *path)
{
	int mode = BDF_HEADER;
	char lbuf[BUFSIZE], *cp;
	FILE *fp;
	struct bdf_header_t bdf_header;
	struct bdf_char_t bdf_char;

	if ((fp = efopen(path, "r")) == NULL)
		return false;

	memset(&bdf_header, 0, sizeof(struct bdf_header_t));
	memset(&bdf_char, 0, sizeof(struct bdf_char_t));

	logging(DEBUG, "read bdf: %s\n", path);

	while (fgets(lbuf, BUFSIZE, fp) != NULL) {
		if ((cp = strchr(lbuf, '\n')) != NULL)
			*cp = '\0';

		//fprintf(stderr, "%s\n", lbuf);

		if (mode == BDF_HEADER)
			mode = read_header(lbuf, &bdf_header);
		else if (mode == BDF_CHAR)
			mode = read_char(lbuf, &bdf_char);
		else if (mode == BDF_BITMAP)
			mode = read_bitmap(glist_head, default_glyph, lbuf, &bdf_header, &bdf_char);
	}
	efclose(fp);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa80, %rsp            # imm = 0xA80
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x11b7(%rip), %rsi      # 0x3010
callq 0x1360
movq %rax, -0x440(%rbp)
cmpq $0x0, %rax
jne 0x1e74
movb $0x0, -0x1(%rbp)
jmp 0x1f78
leaq -0x864(%rbp), %rdi
xorl %esi, %esi
movl $0x424, %edx            # imm = 0x424
callq 0x10b0
leaq -0xa80(%rbp), %rdi
xorl %esi, %esi
movl $0x218, %edx            # imm = 0x218
callq 0x10b0
movq -0x20(%rbp), %rdx
xorl %edi, %edi
leaq 0x1333(%rip), %rsi      # 0x31da
movb $0x0, %al
callq 0x1280
leaq -0x430(%rbp), %rdi
movq -0x440(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x10c0
cmpq $0x0, %rax
je 0x1f68
leaq -0x430(%rbp), %rdi
movl $0xa, %esi
callq 0x10a0
movq %rax, -0x438(%rbp)
cmpq $0x0, %rax
je 0x1ef8
movq -0x438(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0x24(%rbp)
jne 0x1f16
leaq -0x430(%rbp), %rdi
leaq -0x864(%rbp), %rsi
callq 0x1810
movl %eax, -0x24(%rbp)
jmp 0x1f63
cmpl $0x1, -0x24(%rbp)
jne 0x1f34
leaq -0x430(%rbp), %rdi
leaq -0xa80(%rbp), %rsi
callq 0x1b40
movl %eax, -0x24(%rbp)
jmp 0x1f61
cmpl $0x2, -0x24(%rbp)
jne 0x1f5f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x430(%rbp), %rdx
leaq -0x864(%rbp), %rcx
leaq -0xa80(%rbp), %r8
callq 0x1c30
movl %eax, -0x24(%rbp)
jmp 0x1f61
jmp 0x1f63
jmp 0x1eae
movq -0x440(%rbp), %rdi
callq 0x13e0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa80, %rsp            # imm = 0xA80
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/tools/mkfont_bdf.c
// Function: map_glyph
bool map_glyph(struct glyph_t *font[],
	struct glyph_list_t *glist_head, struct glyph_t *default_glyph)
{
	int width, cell_width = 0, cell_height = 0;
	struct glyph_t *glyph;
	struct glyph_list_t *listp;

	if (default_glyph->width == 0 || default_glyph->height == 0) {
		logging(ERROR, "default glyph(U+%.4X) not found\n", DEFAULT_CHAR);
		return false;
	}

	cell_width  = default_glyph->width;
	cell_height = default_glyph->height;
	logging(DEBUG, "default glyph width:%d height:%d\n",
		default_glyph->width, default_glyph->height);

	for (listp = glist_head; listp != NULL; listp = listp->next) {
		if (listp->code >= UCS2_CHARS)
			continue;

		width = wcwidth(listp->code);
		glyph = listp->glyph;
		if ((width <= 0)                                /* not printable */
			|| (glyph->height != cell_height)           /* invalid font height */
			|| (glyph->width  != (cell_width * width))) /* invalid font width */
			continue;

		font[listp->code] = glyph;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0x1fcb
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x1fec
movl $0x2, %edi
leaq 0x1211(%rip), %rsi      # 0x31e8
movl $0x20, %edx
movb $0x0, %al
callq 0x1280
movb $0x0, -0x1(%rbp)
jmp 0x20a2
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %edx
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %ecx
xorl %edi, %edi
leaq 0x11f0(%rip), %rsi      # 0x3209
movb $0x0, %al
callq 0x1280
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x209e
movq -0x40(%rbp), %rax
cmpl $0x10000, (%rax)        # imm = 0x10000
jb 0x203d
jmp 0x2090
movq -0x40(%rbp), %rax
movl (%rax), %edi
callq 0x10f0
movl %eax, -0x24(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x207c
movq -0x38(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl -0x2c(%rbp), %eax
jne 0x207c
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
movl -0x28(%rbp), %ecx
imull -0x24(%rbp), %ecx
cmpl %ecx, %eax
je 0x207e
jmp 0x2090
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movl (%rcx), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x2028
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/tools/mkfont_bdf.c
// Function: load_alias
bool load_alias(struct glyph_t *font[], char *alias)
{
	unsigned int dst, src;
	char buf[BUFSIZE];
	FILE *fp;

	if ((fp = efopen(alias, "r")) == NULL)
		return false;

	while (fgets(buf, BUFSIZE, fp) != NULL) {
		if (strlen(buf) == 0 || buf[0] == '#')
			continue;

		sscanf(buf, "%X %X", &dst, &src);
		if ((dst >= UCS2_CHARS) || (src >= UCS2_CHARS))
			continue;

		//if (font[src] != NULL && font[dst] != NULL) {
		if (font[src] != NULL) {
			logging(DEBUG, "swapped: use U+%.4X for U+%.4X\n", src, dst);
			font[dst] = font[src];

			//free(font[dst]->bitmap);
			//font[dst]->width  = font[src]->width;
			//font[dst]->height = font[src]->height;
			//font[dst]->bitmap = font[src]->bitmap;
			//memcpy(font[dst]->bitmap, font[src]->bitmap, sizeof(bitmap_width_t) * font[src]->height);
		}
	}
	efclose(fp);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xf42(%rip), %rsi       # 0x3010
callq 0x1360
movq %rax, -0x428(%rbp)
cmpq $0x0, %rax
jne 0x20e9
movb $0x0, -0x1(%rbp)
jmp 0x21ad
jmp 0x20eb
leaq -0x420(%rbp), %rdi
movq -0x428(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x10c0
cmpq $0x0, %rax
je 0x219d
leaq -0x420(%rbp), %rdi
callq 0x1090
cmpq $0x0, %rax
je 0x212b
movsbl -0x420(%rbp), %eax
cmpl $0x23, %eax
jne 0x212d
jmp 0x20eb
leaq -0x420(%rbp), %rdi
leaq 0xf95(%rip), %rsi       # 0x30d0
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
movb $0x0, %al
callq 0x1100
cmpl $0x10000, -0x1c(%rbp)   # imm = 0x10000
jae 0x215c
cmpl $0x10000, -0x20(%rbp)   # imm = 0x10000
jb 0x215e
jmp 0x20eb
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x2198
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %ecx
xorl %edi, %edi
leaq 0x10b0(%rip), %rsi      # 0x322b
movb $0x0, %al
callq 0x1280
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x20eb
movq -0x428(%rbp), %rdi
callq 0x13e0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/tools/mkfont_bdf.c
// Function: check_font
bool check_font(struct glyph_t **font, struct glyph_t *empty_half, struct glyph_t *empty_wide)
{
	empty_half->bitmap = (bitmap_width_t *) ecalloc(font[DEFAULT_CHAR]->height, sizeof(bitmap_width_t));
	empty_wide->bitmap = (bitmap_width_t *) ecalloc(font[DEFAULT_CHAR]->height, sizeof(bitmap_width_t));

	if (!empty_half->bitmap || !empty_wide->bitmap)
		return false;

	empty_half->width  = font[DEFAULT_CHAR]->width;
	empty_wide->width  = font[DEFAULT_CHAR]->width * WIDE;
	empty_half->height = font[DEFAULT_CHAR]->height;
	empty_wide->height = font[DEFAULT_CHAR]->height;

	if (font[SUBSTITUTE_HALF] == NULL) {
		logging(WARN, "half substitute glyph(U+%.4X) not found, use empty glyph\n", SUBSTITUTE_HALF);
		font[SUBSTITUTE_HALF] = empty_half;
	}
	if (font[SUBSTITUTE_WIDE] == NULL) {
		logging(WARN, "wide substitute glyph(U+%.4X) not found, use empty glyph\n", SUBSTITUTE_WIDE);
		font[SUBSTITUTE_WIDE] = empty_wide;
	}
	if (font[REPLACEMENT_CHAR] == NULL) {
		logging(WARN, "replacement glyph(U+%.4X) not found, use empty glyph\n", REPLACEMENT_CHAR);
		font[REPLACEMENT_CHAR] = empty_half;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movzbl 0x1(%rax), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x1440
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movzbl 0x1(%rax), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x1440
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2236
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x223f
movb $0x0, -0x1(%rbp)
jmp 0x2337
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movzbl (%rax), %eax
shll %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movb 0x1(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movb 0x1(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x100(%rax)
jne 0x22c9
movl $0x1, %edi
leaq 0xf9d(%rip), %rsi       # 0x324b
movl $0x20, %edx
movb $0x0, %al
callq 0x1280
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x100(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18000(%rax)
jne 0x22fe
movl $0x1, %edi
leaq 0xfa2(%rip), %rsi       # 0x3285
movl $0x3000, %edx           # imm = 0x3000
movb $0x0, %al
callq 0x1280
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18000(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1f8(%rax)
jne 0x2333
movl $0x1, %edi
leaq 0xfa7(%rip), %rsi       # 0x32bf
movl $0x3f, %edx
movb $0x0, %al
callq 0x1280
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1f8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/tools/mkfont_bdf.c
// Function: cleanup
void cleanup(struct glyph_list_t *glist_head, struct glyph_t *empty_half, struct glyph_t *empty_wide)
{
	struct glyph_list_t *listp, *next;

	for (listp = glist_head; listp != NULL; listp = next) {
		next = listp->next;

		free(listp->glyph->bitmap);
		free(listp->glyph);
		free(listp);
	}
	free(empty_half->bitmap);
	free(empty_wide->bitmap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2590
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x254c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/identify/identifyz2.c
// Function: closestNote
char *
closestNote(double freq)
    {
    int i,index = -1;
    for (i = 0; index < 0 && i < 120; ++i)
        {
        if (freq >= freqs[i] && freq < freqs[i+1])
            {
            if (freq - freqs[i] >= freqs[i+1] - freq)
                index = i+1;
            else
                index = i;
            }
        }

    return notes[index];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
jge 0x233c
cmpl $0x78, -0xc(%rbp)
setl %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x2348
jmp 0x23d7
movsd -0x8(%rbp), %xmm0
movslq -0xc(%rbp), %rcx
leaq 0x6dd8(%rip), %rax      # 0x9130
ucomisd (%rax,%rcx,8), %xmm0
jb 0x23c7
movsd -0x8(%rbp), %xmm1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x6dbc(%rip), %rax      # 0x9130
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x23c7
movsd -0x8(%rbp), %xmm0
movslq -0xc(%rbp), %rcx
leaq 0x6da1(%rip), %rax      # 0x9130
subsd (%rax,%rcx,8), %xmm0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x6d8c(%rip), %rax      # 0x9130
movsd (%rax,%rcx,8), %xmm1
subsd -0x8(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jb 0x23bf
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x23c5
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x23c7
jmp 0x23c9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2327
movslq -0x10(%rbp), %rcx
leaq 0x70ae(%rip), %rax      # 0x9490
movq (%rax,%rcx,8), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/./IO_stream.h
// Function: fopen_output_stream
FILE *fopen_output_stream(const char *filename) {
	int fd ;
	if (strncmp(filename,"-", 1)==0 || !strcmp(filename,"")) {
		fd = STDOUT_FILENO;
	} else {
		fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0666 );
		if (fd==-1) err(1, "Failed to create output file (%s)", filename);
	}
	FILE *out = fdopen(fd,"wb");
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x23839(%rip), %rsi     # 0x27010
movl $0x1, %edx
callq 0x30b0
cmpl $0x0, %eax
je 0x37fb
movq -0x8(%rbp), %rdi
leaq 0x24f1d(%rip), %rsi     # 0x2870e
callq 0x3340
cmpl $0x0, %eax
jne 0x3804
movl $0x1, -0xc(%rbp)
jmp 0x383b
movq -0x8(%rbp), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x3520
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x3839
movq -0x8(%rbp), %rdx
movl $0x1, %edi
leaq 0x237e0(%rip), %rsi     # 0x27012
movb $0x0, %al
callq 0x3430
jmp 0x383b
movl -0xc(%rbp), %edi
leaq 0x237ef(%rip), %rsi     # 0x27034
callq 0x34b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/./IO_stream.h
// Function: fcreat_outfile
FILE *fcreat_outfile(const char *outfile,const char *suffix) {
	char *out=(char *)calloc(strlen(outfile)+strlen(suffix)+2,sizeof(char));
	sprintf(out,"%s%s",outfile,suffix);
	FILE *fo=fopen_output_stream(out);
	return fo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq -0x28(%rbp), %rdi
addq %rax, %rdi
addq $0x2, %rdi
movl $0x1, %esi
callq 0x3320
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x23785(%rip), %rsi     # 0x27037
movb $0x0, %al
callq 0x35c0
movq -0x18(%rbp), %rdi
callq 0x37c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/./IO_stream.h
// Function: open_output_stream
gzFile open_output_stream(char* filename) {
	int fd ;
	if (strncmp(filename,"-", 1)==0 || !strcmp(filename,"")) {
		fd = STDOUT_FILENO;
	} else {
		fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0666 );
		if (fd==-1) err(1, "Failed to create output file (%s)", filename);
	}
	gzFile out = gzdopen(fd,"wb");
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x23729(%rip), %rsi     # 0x27010
movl $0x1, %edx
callq 0x30b0
cmpl $0x0, %eax
je 0x390b
movq -0x8(%rbp), %rdi
leaq 0x24e0d(%rip), %rsi     # 0x2870e
callq 0x3340
cmpl $0x0, %eax
jne 0x3914
movl $0x1, -0xc(%rbp)
jmp 0x394b
movq -0x8(%rbp), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x3520
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x3949
movq -0x8(%rbp), %rdx
movl $0x1, %edi
leaq 0x236d0(%rip), %rsi     # 0x27012
movb $0x0, %al
callq 0x3430
jmp 0x394b
movl -0xc(%rbp), %edi
leaq 0x236df(%rip), %rsi     # 0x27034
callq 0x31b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/./IO_stream.h
// Function: creat_outfile
gzFile creat_outfile(const char *outfile,const char *suffix) {
	char *out=(char *)calloc(strlen(outfile)+strlen(suffix)+2,sizeof(char));
	sprintf(out,"%s%s",outfile,suffix);
	gzFile fo=open_output_stream(out);
	return fo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31e0
movq -0x28(%rbp), %rdi
addq %rax, %rdi
addq $0x2, %rdi
movl $0x1, %esi
callq 0x3320
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x23675(%rip), %rsi     # 0x27037
movb $0x0, %al
callq 0x35c0
movq -0x18(%rbp), %rdi
callq 0x38d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/./IO_stream.h
// Function: open_input_stream
gzFile open_input_stream(const char *filename){
	int fd ;
	if (strncmp(filename,"-", 1)==0 || !strcmp(filename,"")) {
		fd = STDIN_FILENO;
	} else {
		fd = open(filename, O_CREAT | O_RDONLY , 0666 );
		if (fd==-1) err(1, "Failed to create input file (%s)", filename);
	}
	gzFile in = gzdopen(fd,"rb");
	return in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x23619(%rip), %rsi     # 0x27010
movl $0x1, %edx
callq 0x30b0
cmpl $0x0, %eax
je 0x3a1b
movq -0x8(%rbp), %rdi
leaq 0x24cfd(%rip), %rsi     # 0x2870e
callq 0x3340
cmpl $0x0, %eax
jne 0x3a24
movl $0x0, -0xc(%rbp)
jmp 0x3a5b
movq -0x8(%rbp), %rdi
movl $0x40, %esi
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x3520
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x3a59
movq -0x8(%rbp), %rdx
movl $0x1, %edi
leaq 0x235ea(%rip), %rsi     # 0x2703c
movb $0x0, %al
callq 0x3430
jmp 0x3a5b
movl -0xc(%rbp), %edi
leaq 0x235f8(%rip), %rsi     # 0x2705d
callq 0x31b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/bam2bedGraph.c
// Function: display_usage
void display_usage(char * argv[]){
	char *buffer=(char* )malloc(8092*sizeof(char));
	const char* usage=
"\nCopyright (c) 2012-2013\n" \
"Contact: XiongXu <xuxiong19880610@163.com> <xiongxu@me.com> \n" \
"Usage: %s [-o OUTFILE] [-r chr1:1-2000000] [-h] bamFile1 bamFile2 ..\n" \
"Discription:\n  This program is used for converting a bam file to wig file format, the bamfile should be samtools indexed. If you don't specify the -r parameter ,the program will convert the whole .bam file by chromosomes\n" \
"Example1:\n  %s -o out -r chr1:1-100000 /share/work1/staff/xuxiong/twins/batch2/test_20131224/RT144FD_L1_I001.R1.clean.fastq.gz_1224/accepted_hits.bam\n" \
"Example2:\n  %s -o out /share/work1/staff/xuxiong/twins/batch2/test_20131224/RT144FD_L1_I001.R1.clean.fastq.gz_1224/accepted_hits.bam\n" \
"\n" \
"   [-o OUTPUT_FILE]  = OUTPUT file.                                   [required]\n" \
"   [-r]              = region, default is whole genome.(chr1:1-20000) [option]\n" \
"   [-h]              = This helpful help screen.                      [option]\n" \
"   Infiles           = bam format input file(s),at least 1 bam file.  [required]\n" \
"\n";
	sprintf(buffer,usage,argv[0],argv[0],argv[0]);
	fprintf(stderr,"%s",buffer);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1f9c, %edi           # imm = 0x1F9C
callq 0x3440
movq %rax, -0x10(%rbp)
leaq 0x2357f(%rip), %rax     # 0x27060
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %r8
movb $0x0, %al
callq 0x35c0
movq 0x2c4e8(%rip), %rax     # 0x2fff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x23e9d(%rip), %rsi     # 0x279bb
movb $0x0, %al
callq 0x3360
movl $0x1, %edi
callq 0x35d0
nop
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/bam2bedGraph.c
// Function: load_bam_index
bam_index_t *load_bam_index(char *filename){
	bam_index_t *idx;
	if ((idx = bam_index_load(filename)) == 0) {
		fprintf(stderr, "bam2bed: BAM indexing file is not available.\n");
		exit(1);
	}
	return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x179e0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x3b71
movq 0x2c4a2(%rip), %rax     # 0x2fff8
movq (%rax), %rdi
leaq 0x238d6(%rip), %rsi     # 0x27436
movb $0x0, %al
callq 0x3360
movl $0x1, %edi
callq 0x35d0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/bam2bedGraph.c
// Function: bam_fetch_chr
int bam_fetch_chr(bam_index_t *idx,const char *region,DataBuf *databuf){
	int ref, beg, end;
	bam_parse_region(databuf->fp->header,region, &ref, &beg, &end);
	if (ref < 0) {
		fprintf(stderr, "bam2bed: Invalid region %s\n", globalArgs.region);
		exit(1);
	}
//	fprintf(stderr,"%s\t%d\t%d\n",databuf->fp->header->target_name[ref],beg,end);
	bam_fetch(databuf->fp->x.bam, idx, ref, beg, end, databuf, fetch_func);
	return ref;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x24(%rbp), %r8
callq 0xd5d0
cmpl $0x0, -0x1c(%rbp)
jge 0x3be3
movq 0x2c437(%rip), %rax     # 0x2fff8
movq (%rax), %rdi
movq 0x2cd75(%rip), %rdx     # 0x30940
leaq 0x23892(%rip), %rsi     # 0x27464
movb $0x0, %al
callq 0x3360
movl $0x1, %edi
callq 0x35d0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
movq -0x18(%rbp), %r9
leaq 0x19(%rip), %rax        # 0x3c20
movq %rax, (%rsp)
callq 0x18d20
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/bam2bedGraph.c
// Function: fetch_func
int fetch_func(const bam1_t *b, void *data) {
	DataBuf *databuf=(DataBuf *)data;
	uint32_t *cigar = bam1_cigar(b);
	const bam1_core_t *c = &b->core;
	if (c->flag&BAM_DEF_MASK || b->core.tid < 0) return 0;
	int i, l;
	unsigned int temp_start= c->pos;
	for (i = l = 0; i < c->n_cigar; ++i) {
		int op = bam_cigar_op(cigar[i]);
		if (op == BAM_CINS) continue;
		if ( op == BAM_CDEL || op == BAM_CREF_SKIP){
			l = bam_cigar_oplen(cigar[i]);
			temp_start+=l;
		}
		else if (op == BAM_CMATCH ) {
			l = bam_cigar_oplen(cigar[i]);
			insertInt2Hash(databuf->Start,temp_start);
			temp_start+=l;
			insertInt2Hash(databuf->End,temp_start);
		}
	}
	databuf->chrRC[c->tid]++;
	databuf->chrReadLen[c->tid]+=l;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x18, %rcx
andq $0xff, %rcx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
andl $0x704, %eax            # imm = 0x704
cmpl $0x0, %eax
jne 0x3c8a
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x3c96
movl $0x0, -0x4(%rbp)
jmp 0x3d92
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x3c(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x30, %rcx
cmpl %ecx, %eax
jge 0x3d58
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0xf, %eax
movl %eax, -0x40(%rbp)
cmpl $0x1, -0x40(%rbp)
jne 0x3cde
jmp 0x3d4a
cmpl $0x2, -0x40(%rbp)
je 0x3cea
cmpl $0x3, -0x40(%rbp)
jne 0x3d06
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x4, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x3d48
cmpl $0x0, -0x40(%rbp)
jne 0x3d46
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shrl $0x4, %eax
movl %eax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x3c(%rbp), %esi
callq 0x4810
movl -0x38(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x3c(%rbp), %esi
callq 0x4810
jmp 0x3d48
jmp 0x3d4a
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3cae
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
movslq (%rcx), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movslq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movslq (%rcx), %rcx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/./int2sds.h
// Function: sds2int
uint32_t sds2int(const sds string){
	uint32_t pos=0;
	int8_t i;
	for (i=sdslen(string)-1; i>=0 ;i-- ){
		pos=pos << 8 | (unsigned char)string[i];
	}
	return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3a80
subq $0x1, %rax
movb %al, -0xd(%rbp)
movsbl -0xd(%rbp), %eax
cmpl $0x0, %eax
jl 0x3e2e
movl -0xc(%rbp), %eax
shll $0x8, %eax
movq -0x8(%rbp), %rcx
movsbq -0xd(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
movb -0xd(%rbp), %al
addb $-0x1, %al
movb %al, -0xd(%rbp)
jmp 0x3e03
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/bam2bedGraph.c
// Function: union_hashed_keys
sds *union_hashed_keys(dict *hashtbl_a,dict *hashtbl_b){
	sds *keys=(sds *)calloc((hashtbl_a->used+hashtbl_b->used),sizeof(sds));
	int j=0;
	dictIterator *iter=dictGetIterator(hashtbl_a);
	dictEntry *entry=dictNext(iter);
	for (;entry;entry=dictNext(iter) ){
		keys[j++]=(sds)(entry->key);
	}
	dictReleaseIterator(iter);

	iter=dictGetIterator(hashtbl_b);
	entry=dictNext(iter);
	for (;entry;entry=dictNext(iter) ){
		keys[j++]=(sds)(entry->key);
	}
	dictReleaseIterator(iter);
	qsort(keys,j,sizeof(sds),cmpInt);
	return keys;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rdi
movl $0x8, %esi
callq 0x3320
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6cd0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6d30
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3ec2
movq -0x30(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdi
callq 0x6d30
movq %rax, -0x30(%rbp)
jmp 0x3e8f
movq -0x28(%rbp), %rdi
callq 0x6de0
movq -0x10(%rbp), %rdi
callq 0x6cd0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6d30
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3f18
movq -0x30(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdi
callq 0x6d30
movq %rax, -0x30(%rbp)
jmp 0x3ee5
movq -0x28(%rbp), %rdi
callq 0x6de0
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movl $0x8, %edx
leaq -0x195(%rip), %rcx      # 0x3da0
callq 0x3110
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/bam2bedGraph.c
// Function: region_sam2wig
void region_sam2wig(DataBuf *databuf ,bam_index_t *idx,const char *region,FILE *bedGraph,dictType *mydictType){
	databuf->Start=dictCreate(mydictType,NULL);
	databuf->End=dictCreate(mydictType,NULL);
	int ref=bam_fetch_chr(idx,region,databuf);
	hash2BedGraph(databuf,ref,bedGraph);
	dictRelease(databuf->Start);
	dictRelease(databuf->End);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x63a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x63a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x3b80
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x3f50
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6b70
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6b70
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/bam2bedGraph.c
// Function: insertInt2Hash
int insertInt2Hash(dict *Start,uint32_t pos) {
	sds value=int2sds(pos);
	dictEntry *val_data=dictFind(Start,value);
	if (val_data==NULL) {
		int *init=(int *)malloc(sizeof(int));
		*init=1;
		dictAdd(Start,value,init);
	}
	else{
		(*(int *)val_data->val)++;
	}
	sdsfree(value);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x4890
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6910
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x486e
movl $0x4, %edi
callq 0x3440
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6640
jmp 0x487d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x4ae0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/./int2sds.h
// Function: int2sds
sds int2sds(uint32_t pos){
	short codeLen=1;
	if (pos>16777215){
		codeLen=4;
	}else if(pos>65535){
		codeLen=3;
	}else if(pos>255){
		codeLen=2;
	}
	sds value=sdsnewlen(NULL,codeLen);
	short i;
	for (i=codeLen-1;i>=0 ;i-- )
		value[i]= pos>>(i*8) & 0xFF;
	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movw $0x1, -0x6(%rbp)
cmpl $0xffffff, -0x4(%rbp)   # imm = 0xFFFFFF
jbe 0x48b2
movw $0x4, -0x6(%rbp)
jmp 0x48d6
cmpl $0xffff, -0x4(%rbp)     # imm = 0xFFFF
jbe 0x48c3
movw $0x3, -0x6(%rbp)
jmp 0x48d4
cmpl $0xff, -0x4(%rbp)
jbe 0x48d2
movw $0x2, -0x6(%rbp)
jmp 0x48d4
jmp 0x48d6
movswq -0x6(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x4980
movq %rax, -0x10(%rbp)
movswl -0x6(%rbp), %eax
subl $0x1, %eax
movw %ax, -0x12(%rbp)
movswl -0x12(%rbp), %eax
cmpl $0x0, %eax
jl 0x4929
movl -0x4(%rbp), %eax
movswl -0x12(%rbp), %ecx
shll $0x3, %ecx
shrl %cl, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movswq -0x12(%rbp), %rcx
movb %dl, (%rax,%rcx)
movw -0x12(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x12(%rbp)
jmp 0x48f3
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/hiredis/./dict.c
// Function: dictDelete
int dictDelete(dict *ht, const void *key) {
    unsigned int h;
    dictEntry *de, *prevde;

    if (ht->size == 0)
        return DICT_ERR;
    h = dictHashKey(ht, key) & ht->sizemask;
    de = ht->table[h];

    prevde = NULL;
    while(de) {
        if (!dictCompareHashKeys(ht,key,de->key)) {
            /* Unlink the element from the list */
            if (prevde)
                prevde->next = de->next;
            else
                ht->table[h] = de->next;

            dictFreeEntryKey(ht,de);
            dictFreeEntryVal(ht,de);
            free(de);
            ht->used--;
            return DICT_OK;
        }
        prevde = de;
        de = de->next;
    }
    return DICT_ERR; /* not found */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x6a07
movl $0x1, -0x4(%rbp)
jmp 0x6b60
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movl %eax, %eax
movq -0x10(%rbp), %rcx
andq 0x18(%rcx), %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6b59
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x6a85
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq (%rcx), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0x6b40
jmp 0x6a96
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
je 0x6b40
cmpq $0x0, -0x30(%rbp)
je 0x6aaf
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x6ac5
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x6af1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
movq -0x28(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x6b1e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq -0x28(%rbp), %rdi
callq 0x3050
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x6b60
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x6a3f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/hiredis/hiredis.c
// Function: redisFree
void redisFree(redisContext *c) {
    if (c == NULL)
        return;
    if (c->fd > 0)
        close(c->fd);
    if (c->obuf != NULL)
        sdsfree(c->obuf);
    if (c->reader != NULL)
        redisReaderFree(c->reader);
    free(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa9d5
jmp 0xaa36
movq -0x8(%rbp), %rax
cmpl $0x0, 0x84(%rax)
jle 0xa9f1
movq -0x8(%rbp), %rax
movl 0x84(%rax), %edi
callq 0x3290
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0xaa0f
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x4ae0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0xaa2d
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x93e0
movq -0x8(%rbp), %rdi
callq 0x3050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiongxu[P]bam2bedGraph2/samtools-0.1.19/bam_index.c
// Function: download_from_remote
static void download_from_remote(const char *url)
{
	const int buf_size = 1 * 1024 * 1024;
	char *fn;
	FILE *fp;
	uint8_t *buf;
	knetFile *fp_remote;
	int l;
	if (strstr(url, "ftp://") != url && strstr(url, "http://") != url) return;
	l = strlen(url);
	for (fn = (char*)url + l - 1; fn >= url; --fn)
		if (*fn == '/') break;
	++fn; // fn now points to the file name
	fp_remote = knet_open(url, "r");
	if (fp_remote == 0) {
		fprintf(stderr, "[download_from_remote] fail to open remote file.\n");
		return;
	}
	if ((fp = fopen(fn, "wb")) == 0) {
		fprintf(stderr, "[download_from_remote] fail to create file in the working directory.\n");
		knet_close(fp_remote);
		return;
	}
	buf = (uint8_t*)calloc(buf_size, 1);
	while ((l = knet_read(fp_remote, buf, buf_size)) != 0)
		fwrite(buf, 1, l, fp);
	free(buf);
	fclose(fp);
	knet_close(fp_remote);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x100000, -0xc(%rbp)   # imm = 0x100000
movq -0x8(%rbp), %rdi
leaq 0x10c21(%rip), %rsi     # 0x2870f
callq 0x3660
cmpq -0x8(%rbp), %rax
je 0x17b14
movq -0x8(%rbp), %rdi
leaq 0x10c12(%rip), %rsi     # 0x28716
callq 0x3660
cmpq -0x8(%rbp), %rax
je 0x17b14
jmp 0x17c3c
movq -0x8(%rbp), %rdi
callq 0x31e0
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jb 0x17b5b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x17b4b
jmp 0x17b5b
jmp 0x17b4d
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x17b33
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xfb19(%rip), %rsi      # 0x2768b
callq 0x1de60
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x17b9f
movq 0x1846f(%rip), %rax     # 0x2fff8
movq (%rax), %rdi
leaq 0x10df9(%rip), %rsi     # 0x2898c
movb $0x0, %al
callq 0x3360
jmp 0x17c3c
movq -0x18(%rbp), %rdi
leaq 0xf48a(%rip), %rsi      # 0x27034
callq 0x3380
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x17bdc
movq 0x18438(%rip), %rax     # 0x2fff8
movq (%rax), %rdi
leaq 0x10df4(%rip), %rsi     # 0x289be
movb $0x0, %al
callq 0x3360
movq -0x30(%rbp), %rdi
callq 0x1e000
jmp 0x17c3c
movl $0x100000, %edi         # imm = 0x100000
movl $0x1, %esi
callq 0x3320
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x100000, %edx         # imm = 0x100000
callq 0x1e110
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x17c21
movq -0x28(%rbp), %rdi
movslq -0x34(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x35f0
jmp 0x17bef
movq -0x28(%rbp), %rdi
callq 0x3050
movq -0x20(%rbp), %rdi
callq 0x31d0
movq -0x30(%rbp), %rdi
callq 0x1e000
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/timocramer[P]thinklight-fun/tl-onofftoggle.c
// Function: main
int main(void) {
	if(tl_init()) {
		write(2, ERROR_MESSAGE, sizeof(ERROR_MESSAGE) - 1);
		return 1;
	}
	
#ifdef ON
	tl_on();
#elif defined OFF
	tl_off();
#elif defined TOGGLE
	tl_toggle();
#endif
	
	tl_deinit();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x11d0
cmpl $0x0, %eax
je 0x11a8
movl $0x2, %edi
leaq 0xe6f(%rip), %rsi       # 0x2004
movl $0x22, %edx
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x11b9
callq 0x1250
callq 0x1220
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)