LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/uuencode.c
// Function: UUENCODE_is_file_uuencoded
int UUENCODE_is_file_uuencoded( char *fname )
{
	int result = 0;
	int linecount = 0;
	int limit=20;
	char line[ UUENCODE_STRLEN_MAX ];
	FILE *f;

	f = fopen(fname,"r");
	if (!f)
	{
		LOGGER_log("%s:%d:UUENCODE_is_file_uuencoded:ERROR: cannot open file '%s' for reading (%s)", FL, fname,strerror(errno));
		uuencode_error = UUENCODE_STATUS_CANNOT_OPEN_FILE;
		return -1;
	}

	while ((linecount < limit)&&(fgets(line, sizeof(line), f)))
	{
		if (UUENCODE_DNORMAL) LOGGER_log("%s:%d:UUENCODE_is_file_uuencoded:DEBUG: Testing line '%s'\n", FL, line);
		if (UUENCODE_is_uuencode_header( line ))
		{
			result = 1;
			break;
		}
		linecount++;
	}

	fclose(f);

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x14, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa2e5(%rip), %rsi      # 0x1d694
callq 0x2330
movq %rax, -0x428(%rbp)
cmpq $0x0, -0x428(%rbp)
jne 0x13416
movq -0x10(%rbp), %rax
movq %rax, -0x430(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x23a0
movq -0x430(%rbp), %rcx
movq %rax, %r8
leaq 0xbf65(%rip), %rdi      # 0x1f352
leaq 0xbef2(%rip), %rsi      # 0x1f2e6
movl $0x13e, %edx            # imm = 0x13E
movb $0x0, %al
callq 0x117c0
movl $0x65, 0x22986(%rip)    # 0x35d90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x134bd
jmp 0x13418
movl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x431(%rbp)
jge 0x1344d
leaq -0x420(%rbp), %rdi
movq -0x428(%rbp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x21d0
cmpq $0x0, %rax
setne %al
movb %al, -0x431(%rbp)
movb -0x431(%rbp), %al
testb $0x1, %al
jne 0x13459
jmp 0x134ab
cmpl $0x1, 0x22910(%rip)     # 0x35d70
jl 0x13483
leaq -0x420(%rbp), %rcx
leaq 0xbf31(%rip), %rdi      # 0x1f3a1
leaq 0xbe6f(%rip), %rsi      # 0x1f2e6
movl $0x145, %edx            # imm = 0x145
movb $0x0, %al
callq 0x117c0
leaq -0x420(%rbp), %rdi
callq 0x131a0
cmpl $0x0, %eax
je 0x1349d
movl $0x1, -0x14(%rbp)
jmp 0x134ab
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x13418
movq -0x428(%rbp), %rdi
callq 0x20e0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/filename-filters.c
// Function: FNFILTER_init
int FNFILTER_init( void )
{
    glb.debug = 0;
    glb.verbose = 0;
    glb.paranoid = 0;
    glb.x_mac = 0;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x21b66(%rip)     # 0x35d94
movl $0x0, 0x21b60(%rip)     # 0x35d98
movl $0x0, 0x21b5a(%rip)     # 0x35d9c
movl $0x0, 0x21b54(%rip)     # 0x35da0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ole.c
// Function: OLE_init
int OLE_init( struct OLE_object *ole )
{
	ole->debug = 0;
	ole->verbose = 0;
	ole->quiet = 0;
	ole->filename_report_fn = NULL;
	ole->f = NULL;
	ole->file_size = 0;

	ole->FAT = NULL;
	ole->FAT_limit = NULL;
	ole->miniFAT = NULL;
	ole->miniFAT_limit = NULL;

	ole->header_block[0] = '\0';
	ole->ministream = NULL;
	ole->properties = NULL;

	ole->header.sector_shift = 0;
	ole->header.mini_sector_shift = 0;

	return OLE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x444(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x448(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x44c(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x470(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x248(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x250(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x264(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x26c(%rax)
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ole.c
// Function: OLE_dir_init
int OLE_dir_init(struct OLE_directory_entry *dir )
{
	memset(dir->element_name,'\0', OLE_DIRECTORY_ELEMENT_NAME_SIZE);
	dir->element_name_byte_count = 0;

	dir->element_type = 0;
	dir->element_colour = 0;

	dir->left_child = 0;
	dir->right_child = 0;
	dir->root = 0;

	dir->class[0] = '\0';
	dir->userflags = 0;
	dir->timestamps[0] = '\0';
	dir->start_sector = 0;
	dir->stream_size = 0;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2150
movq -0x8(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x44(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x45(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x54(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x64(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x68(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x80(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ole.c
// Function: OLE_set_quiet
int OLE_set_quiet( struct OLE_object *ole, int level )
{
	ole->quiet = level;
	ole->verbose = 0;
	ole->debug = 0;

	return OLE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x448(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x444(%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ole.c
// Function: OLE_get_miniblock
int OLE_get_miniblock( struct OLE_object *ole, int block_index, unsigned char *block_buffer )
{
	if (ole->ministream)
	{
		int offset = block_index << ole->header.mini_sector_shift;

		memcpy( block_buffer, ole->ministream +offset, ole->header.mini_sector_size);
	}

	return OLE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x248(%rax)
je 0x14eaa
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x26c(%rcx), %ecx
shll %cl, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x248(%rax), %rsi
movslq -0x1c(%rbp), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movl 0x270(%rax), %eax
movl %eax, %edx
callq 0x2250
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ole.c
// Function: OLE_dbstosbs
int OLE_dbstosbs( char *raw_string, size_t byte_count, char *clean_string, int clean_string_len )
{
	char *limit = raw_string +byte_count -1;

	clean_string_len--;

	while ((raw_string < limit)&&(byte_count >0)&&(byte_count--)&&(clean_string_len--))
	{
		int v = (char)*raw_string;

		if (isprint(v))
		{
			*clean_string = v;
			clean_string++;
		}

		raw_string += 2;
	}
	*clean_string = '\0';

	return OLE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x2d(%rbp)
jae 0x14f39
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x2d(%rbp)
jbe 0x14f39
movq -0x10(%rbp), %rcx
movq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x2d(%rbp)
je 0x14f39
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x14f42
jmp 0x14f8e
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
callq 0x23c0
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x14f7d
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x14ef0
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ole.c
// Function: OLE_print_string
int OLE_print_string( char *string, size_t char_count)
{
	while (char_count--)
	{
		printf("%c",*string);
		string += 2;
	}
	return OLE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0x14fe8
movq -0x8(%rbp), %rax
movsbl (%rax), %esi
leaq 0x7c84(%rip), %rdi      # 0x1cc57
movb $0x0, %al
callq 0x2120
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x14fb0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ole.c
// Function: OLE_print_sector
int OLE_print_sector( struct OLE_object *ole, char *sector, unsigned int bytes)
{
	int current_byte;
	int ubytes = bytes;

	printf("\n");
	for (current_byte = 0; current_byte < ubytes; current_byte++ )
	{
		printf("%02X ", *(sector +current_byte));
		if (((current_byte+1) %32)==0) {
			int j;
			for (j = current_byte -31; j <=current_byte; j++)
			{
				if (isalnum(*(sector +j))) printf("%c",*(sector+j));
				else printf(".");
			}
			printf("\n");
		}
	}
	printf("\n");

	return OLE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq 0x49f6(%rip), %rdi      # 0x19a06
movb $0x0, %al
callq 0x2120
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x150e0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0xaea5(%rip), %rdi      # 0x1fee2
movb $0x0, %al
callq 0x2120
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl $0x20, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x150d0
movl -0x18(%rbp), %eax
subl $0x1f, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x150c2
callq 0x23c0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x150a7
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x7bb9(%rip), %rdi      # 0x1cc57
movb $0x0, %al
callq 0x2120
jmp 0x150b5
leaq 0x5d6f(%rip), %rdi      # 0x1ae1d
movb $0x0, %al
callq 0x2120
jmp 0x150b7
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x15060
leaq 0x493d(%rip), %rdi      # 0x19a06
movb $0x0, %al
callq 0x2120
jmp 0x150d2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1501e
leaq 0x491f(%rip), %rdi      # 0x19a06
movb $0x0, %al
callq 0x2120
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ole.c
// Function: OLE_get_header
int OLE_get_header( struct OLE_object *ole )
{
	int result = 0;
	ole->header.sector_size = OLE_HEADER_BLOCK_SIZE;
	result = OLE_get_block( ole, -1, ole->header_block );
	if (result != 0) return result;

	if (OLE_is_file_OLE( ole ) == 0)
	{
		return OLEER_NOT_OLE_FILE;
	}

	return OLE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl $0x200, 0x268(%rax)     # imm = 0x200
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x48, %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14ae0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x151b8
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x151d6
movq -0x10(%rbp), %rdi
callq 0x15100
cmpl $0x0, %eax
jne 0x151cf
movl $0x66, -0x4(%rbp)
jmp 0x151d6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ole.c
// Function: OLE_header_sanity_check
int OLE_header_sanity_check( struct OLE_object *ole )
{
	int insanity=0;
	int max_sectors;
	struct OLE_header *h;

	h = &(ole->header);

	max_sectors = ole->file_size / h->sector_size;

	if (h->sector_shift > 20) insanity++;
	if (h->mini_sector_shift > 10) insanity++;
	if (h->fat_sector_count < 0) insanity++;
	if (h->fat_sector_count > max_sectors) insanity++;
	if (h->directory_stream_start_sector > max_sectors) insanity++;

	return insanity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x258, %rax            # imm = 0x258
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x14, 0xc(%rax)
jbe 0x15407
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xa, 0x14(%rax)
jbe 0x1541a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jae 0x1542d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %eax
cmpl -0x10(%rbp), %eax
jbe 0x15442
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x10(%rbp), %eax
jbe 0x15457
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ole.c
// Function: OLE_print_header
int OLE_print_header( struct OLE_object *ole )
{
	unsigned int i;
	struct OLE_header *h;

	h = &(ole->header);

	printf( "Minor version = %d\n"
			"DLL version = %d\n"
			"Byte order = %d\n\n"

			"Sector shift = %d\n"
			"Sector size  = %d\n"
			"Mini Sector shift = %d\n"
			"Mini sector size  = %d\n\n"

			"FAT sector count = %d\n"
			"First FAT sector = %d\n\n"

			"Maximum ministream size = %d\n\n"

			"First MiniFAT sector = %d\n"
			"MiniFAT sector count = %d\n\n"

			"First DIF sector = %d\n"
			"DIF sector count = %d\n"
			"--------------------------------\n"
			,h->minor_version
			,h->dll_version
			,h->byte_order
			,h->sector_shift
			,h->sector_size
			,h->mini_sector_shift
			,h->mini_sector_size
			,h->fat_sector_count
			,h->directory_stream_start_sector
			,h->mini_cutoff_size
			,h->mini_fat_start
			,h->mini_fat_sector_count
			,h->dif_start_sector
			,h->dif_sector_count
			);

	// Print out the FAT chain
	for (i = 0; i < h->fat_sector_count; i++)
	{
		if (i >= OLE_HEADER_FAT_SECTOR_COUNT_LIMIT) break; // We can't read beyond the 109th sector location
		printf("FAT[%d] = %d\n", i, h->FAT[i]);
	}

	return OLE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x258, %rax            # imm = 0x258
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %esi
movq -0x40(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x40(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x40(%rbp), %rax
movl 0xc(%rax), %r8d
movq -0x40(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x40(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x40(%rbp), %rdi
movl 0x18(%rdi), %r13d
movq -0x40(%rbp), %rdi
movl 0x1c(%rdi), %r12d
movq -0x40(%rbp), %rdi
movl 0x20(%rdi), %r15d
movq -0x40(%rbp), %rdi
movl 0x24(%rdi), %r14d
movq -0x40(%rbp), %rdi
movl 0x28(%rdi), %ebx
movq -0x40(%rbp), %rdi
movl 0x2c(%rdi), %r11d
movq -0x40(%rbp), %rdi
movl 0x30(%rdi), %r10d
movq -0x40(%rbp), %rdi
movl 0x34(%rdi), %edi
movl %edi, -0x44(%rbp)
leaq 0xa9f2(%rip), %rdi      # 0x1fee8
movl %eax, (%rsp)
movl -0x44(%rbp), %eax
movl %r13d, 0x8(%rsp)
movl %r12d, 0x10(%rsp)
movl %r15d, 0x18(%rsp)
movl %r14d, 0x20(%rsp)
movl %ebx, 0x28(%rsp)
movl %r11d, 0x30(%rsp)
movl %r10d, 0x38(%rsp)
movl %eax, 0x40(%rsp)
movb $0x0, %al
callq 0x2120
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x40(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jae 0x1556b
cmpl $0x6d, -0x34(%rbp)
jb 0x15544
jmp 0x1556b
movl -0x34(%rbp), %esi
movq -0x40(%rbp), %rax
movl -0x34(%rbp), %ecx
movl 0x38(%rax,%rcx,4), %edx
leaq 0xaae5(%rip), %rdi      # 0x2003e
movb $0x0, %al
callq 0x2120
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x15530
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ole.c
// Function: OLE_print_directory
int OLE_print_directory( struct OLE_object *ole, struct OLE_directory_entry *dir )
{
	char element[64];
	OLE_dbstosbs( dir->element_name, dir->element_name_byte_count, element, sizeof(element) );

	printf(
			"Element Name = %s\n"
			"Element type = %d\n"
			"Element colour = %d\n"
			"Left Child = %d\n"
			"Right Child = %d\n"
			"Root = %d\n"
			"User flags = %d\n"
			"Start sector = %ld\n"
			"Stream Size = %d\n"
			,element
			,dir->element_type
			,dir->element_colour
			,dir->left_child
			,dir->right_child
			,dir->root
			,dir->userflags
			,dir->start_sector
			,dir->stream_size
			);

	return OLE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq 0x40(%rax), %rsi
leaq -0x60(%rbp), %rdx
movl $0x40, %ecx
callq 0x14ec0
leaq -0x60(%rbp), %rsi
movq -0x18(%rbp), %rax
movsbl 0x44(%rax), %edx
movq -0x18(%rbp), %rax
movsbl 0x45(%rax), %ecx
movq -0x18(%rbp), %rax
movl 0x48(%rax), %r8d
movq -0x18(%rbp), %rax
movl 0x4c(%rax), %r9d
movq -0x18(%rbp), %rax
movl 0x50(%rax), %ebx
movq -0x18(%rbp), %rax
movl 0x64(%rax), %r11d
movq -0x18(%rbp), %rax
movq 0x78(%rax), %r10
movq -0x18(%rbp), %rax
movl 0x80(%rax), %eax
leaq 0xa902(%rip), %rdi      # 0x20089
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movb $0x0, %al
callq 0x2120
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ole.c
// Function: OLE_open_file
int OLE_open_file( struct OLE_object *ole, char *fullpath )
{
	struct stat st;
	int stat_result;
	FILE *f;

	stat_result = stat(fullpath, &st);
	if (stat_result != 0) {
		DOLE LOGGER_log("%s:%d:OLE_open_file:ERROR: Cannot locate file '%s' for opening (%s)",FL, fullpath, strerror(errno));
		return OLEER_BAD_INPUT_FILE;
	}

	DOLE LOGGER_log("%s:%d:OLE_open_file:DEBUG: File size of %s = %ld",FL, fullpath, st.st_size);
	if ((stat_result == 0) && (st.st_size < 512)) return OLEER_NOT_OLE_FILE;

	ole->file_size = st.st_size;

	f = fopen(fullpath,"r");
	if (f == NULL)
	{
		ole->f = NULL;
		if (ole->quiet == 0)
		{
			LOGGER_log("%s:%d:OLE_open_file:ERROR:Cannot open %s for reading (%s)\n",FL,fullpath, strerror(errno));
		}
		return -1;
	} else {
		ole->f = f;
		ole->file_size = st.st_size;
		ole->last_sector = -1;
	}
	return OLE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x2230
movl %eax, -0xac(%rbp)
cmpl $0x0, -0xac(%rbp)
je 0x166f6
movq -0x10(%rbp), %rax
cmpl $0x0, 0x444(%rax)
je 0x166ea
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x23a0
movq -0xc0(%rbp), %rcx
movq %rax, %r8
leaq 0xa372(%rip), %rdi      # 0x20a49
leaq 0x956d(%rip), %rsi      # 0x1fc4b
movl $0x580, %edx            # imm = 0x580
movb $0x0, %al
callq 0x117c0
movl $0x65, -0x4(%rbp)
jmp 0x167fb
movq -0x10(%rbp), %rax
cmpl $0x0, 0x444(%rax)
je 0x16725
movq -0x18(%rbp), %rcx
movq -0x78(%rbp), %r8
leaq 0xa37b(%rip), %rdi      # 0x20a8d
leaq 0x9532(%rip), %rsi      # 0x1fc4b
movl $0x584, %edx            # imm = 0x584
movb $0x0, %al
callq 0x117c0
cmpl $0x0, -0xac(%rbp)
jne 0x16744
cmpq $0x200, -0x78(%rbp)     # imm = 0x200
jge 0x16744
movl $0x66, -0x4(%rbp)
jmp 0x167fb
movq -0x78(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
leaq 0x6f39(%rip), %rsi      # 0x1d694
callq 0x2330
movq %rax, -0xb8(%rbp)
cmpq $0x0, -0xb8(%rbp)
jne 0x167ce
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x44c(%rax)
jne 0x167c5
movq -0x18(%rbp), %rax
movq %rax, -0xc8(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x23a0
movq -0xc8(%rbp), %rcx
movq %rax, %r8
leaq 0xa30c(%rip), %rdi      # 0x20abe
leaq 0x9492(%rip), %rsi      # 0x1fc4b
movl $0x58f, %edx            # imm = 0x58F
movb $0x0, %al
callq 0x117c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x167fb
movq -0xb8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x78(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ole.c
// Function: OLE_open_directory
int OLE_open_directory( struct OLE_object *ole, char *directory )
{
	int result=0;

	result = mkdir( directory, S_IRWXU );
	if ((result != 0)&&(errno != EEXIST))
	{
		LOGGER_log("%s:%d:OLE_open_directory:ERROR: %s",FL,strerror(errno));
	} else result = OLE_OK;

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x20a0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x16873
callq 0x2050
cmpl $0x11, (%rax)
je 0x16873
callq 0x2050
movl (%rax), %edi
callq 0x23a0
movq %rax, %rcx
leaq 0xa29b(%rip), %rdi      # 0x20af9
leaq 0x93e6(%rip), %rsi      # 0x1fc4b
movl $0x5b2, %edx            # imm = 0x5B2
movb $0x0, %al
callq 0x117c0
jmp 0x1687a
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ole.c
// Function: OLE_decode_file_done
int OLE_decode_file_done( struct OLE_object *ole )
{
	if (ole->f) fclose(ole->f);
	/** Why weren't these active? (they were commented out ) **/
	if (ole->FAT) free(ole->FAT);
	if (ole->miniFAT) free(ole->miniFAT);
	if (ole->ministream) free(ole->ministream);
	if (ole->properties) free(ole->properties);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x16a64
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x20e0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x16a7c
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x16a94
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
cmpq $0x0, 0x248(%rax)
je 0x16ab2
movq -0x8(%rbp), %rax
movq 0x248(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
cmpq $0x0, 0x250(%rax)
je 0x16ad0
movq -0x8(%rbp), %rax
movq 0x250(%rax), %rdi
callq 0x2030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/olestream-unwrap.c
// Function: OLEUNWRAP_init
int OLEUNWRAP_init( struct OLEUNWRAP_object *oleuw )
{
	oleuw->debug = 0;
	oleuw->verbose = 0;
	oleuw->filename_report_fn = NULL;

	return OLEUW_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/olestream-unwrap.c
// Function: OLEUNWRAP_sanitize_filename
int OLEUNWRAP_sanitize_filename( char *fname )
{

	if (fname == NULL) return 0;

		while (*fname)
		{
			if( !isalnum((int)*fname) && (*fname != '.') ) *fname='_';
			if( (*fname < ' ')||(*fname > '~') ) *fname='_';
			fname++;
		}
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1779c
movl $0x0, -0x4(%rbp)
jmp 0x1780c
jmp 0x1779e
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x17805
callq 0x23c0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x177d8
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x177d8
movq -0x10(%rbp), %rax
movb $0x5f, (%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jl 0x177f0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jle 0x177f7
movq -0x10(%rbp), %rax
movb $0x5f, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1779e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/olestream-unwrap.c
// Function: OLEUNWRAP_decodestream
int OLEUNWRAP_decodestream( struct OLEUNWRAP_object *oleuw, char *element_string, char *stream, size_t stream_size, char *decode_path )
{
	int result = OLEUW_OK;

	if (strstr(element_string, OLEUW_ELEMENT_10NATIVE_STRING) != NULL) 
	{
		
		DUW LOGGER_log("%s:%d:OLEUNWRAP_decodestream:DEBUG: Debugging element '%s'",FL, element_string);
		OLEUNWRAP_decode_attachment( oleuw, stream, stream_size, decode_path );

	} else if (strstr(element_string, OLEUW_ELEMENT_DATA) != NULL)  {

		DUW LOGGER_log("%s:%d:OLEUNWRAP_decodestream:DEBUG: Debugging element '%s'",FL, element_string);
		OLEUNWRAP_decode_attachment( oleuw, stream, stream_size, decode_path );

	} else {
		DUW LOGGER_log("%s:%d:OLEUNWRAP_decode_attachment:DEBUG: Unable to decode stream with element string '%s'\n", FL, element_string);
		result = OLEUW_STREAM_NOT_DECODED;
	}

	return result;
}

// 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)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x99d2(%rip), %rsi      # 0x219d0
callq 0x23b0
cmpq $0x0, %rax
je 0x1804b
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x18031
movq -0x10(%rbp), %rcx
leaq 0x99be(%rip), %rdi      # 0x219dc
leaq 0x92b7(%rip), %rsi      # 0x212dc
movl $0x1dc, %edx            # imm = 0x1DC
movb $0x0, %al
callq 0x117c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x17980
jmp 0x180d1
movq -0x10(%rbp), %rdi
leaq 0x99c1(%rip), %rsi      # 0x21a17
callq 0x23b0
cmpq $0x0, %rax
je 0x180a0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x18089
movq -0x10(%rbp), %rcx
leaq 0x9966(%rip), %rdi      # 0x219dc
leaq 0x925f(%rip), %rsi      # 0x212dc
movl $0x1e1, %edx            # imm = 0x1E1
movb $0x0, %al
callq 0x117c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x17980
jmp 0x180cf
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x180c8
movq -0x10(%rbp), %rcx
leaq 0x9967(%rip), %rdi      # 0x21a1c
leaq 0x9220(%rip), %rsi      # 0x212dc
movl $0x1e5, %edx            # imm = 0x1E5
movb $0x0, %al
callq 0x117c0
movl $0x64, -0x2c(%rbp)
jmp 0x180d1
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/bytedecoders.c
// Function: get_int32
int get_int32( char *start )
{
	int value = 0;

	value = (int)((unsigned char)*start)
		|(((unsigned char)*(start +1)) << 8) 
		|(((unsigned char)*(start +2)) << 16) 
		|(((unsigned char)*(start +3)) << 24);

//	printf("String=0x%x %x %x %x:%u = %d\n", *start, *(start +1), *(start +2), *(start +3), *(start +3), value);

	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/bt-int.c
// Function: BTI_add
int BTI_add( struct bti_node **n, int value )
{
	int collision = 0;
	int dir = 0;
	struct bti_node *p = NULL, *node = *n;

//	fprintf(stdout,"Adding %d to %p\n", value, *n);
	while (node != NULL)
	{
		if (value > node->data) { p = node; dir=1;  node = node->r; }
		else if (value < node->data) { p = node; dir=-1; node = node->l; }
		else if (value == node->data) 
		{
			collision = 1;
			break;
		}
	}

	if (collision == 0)
	{
		struct bti_node *leaf;

		leaf = malloc(sizeof(struct bti_node));
		if (leaf == NULL)
		{
			return -1;
		}

		leaf->data = value;
		leaf->l = leaf->r = NULL;

		if (p != NULL)
		{
			switch (dir) {
				case 1: 
					p->r = leaf;
					break;
				case -1: 
					p->l = leaf;
					break;
			}
		} else {
			*n = leaf;
		}


	}

	return collision;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x18301
movl -0x14(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x182bf
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x182ff
movl -0x14(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x182e7
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x182fd
movl -0x14(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x182fb
movl $0x1, -0x18(%rbp)
jmp 0x18301
jmp 0x182fd
jmp 0x182ff
jmp 0x18290
cmpl $0x0, -0x18(%rbp)
jne 0x18391
movl $0x18, %edi
callq 0x2290
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x18329
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x18397
movl -0x14(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x8(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x18384
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $-0x1, %eax
je 0x18376
jmp 0x1835e
movl -0x3c(%rbp), %eax
subl $0x1, %eax
jne 0x18382
jmp 0x18368
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x18382
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1838f
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x18391
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/bt-int.c
// Function: BTI_dump
int BTI_dump( struct bti_node **n )
{
		struct bti_node *node;

	node = *n;
	
	if (node->l) BTI_dump(&(node->l)); 
	if (*n) { fprintf(stdout,"%d, ", node->data); }
	if (node->r) BTI_dump(&(node->r));

	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x183cf
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x183a0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x183f7
movq 0xdbf0(%rip), %rax      # 0x25fd0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq 0x9687(%rip), %rsi      # 0x21a77
movb $0x0, %al
callq 0x2200
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1840f
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x183a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/bt-int.c
// Function: BTI_done
int BTI_done( struct bti_node **n )
{
	struct bti_node *node;

	if (n == NULL) return 0;
	if (*n == NULL) return 0;

	node = *n;
	
	if (node->l) BTI_done(&(node->l)); 
	if (node->r) BTI_done(&(node->r));
	if (*n) { free(*n); *n = NULL; }

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1843c
movl $0x0, -0x4(%rbp)
jmp 0x184b2
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1844f
movl $0x0, -0x4(%rbp)
jmp 0x184b2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x18472
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x18420
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1848a
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x18420
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x184ab
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/writeseek3.c
// Function: testcase_prepare
void testcase_prepare(unsigned long nr_tasks)
{
	char buf[BUFLEN];
	int fd = mkstemp(tmpfile);
	unsigned long left = getpagesize() * nr_tasks;

	memset(buf, 0, sizeof(buf));
	assert(fd >= 0);

	while (left > 0) {
		int n = write(fd, buf, sizeof(buf));
		assert(n > 0);
		left -= n;
	}
	close(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
leaq 0x31ba(%rip), %rdi      # 0x61a0
callq 0x21d0
movl %eax, -0x1014(%rbp)
callq 0x2280
cltq
imulq -0x8(%rbp), %rax
movq %rax, -0x1020(%rbp)
leaq -0x1010(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2130
cmpl $0x0, -0x1014(%rbp)
jl 0x3022
jmp 0x3041
leaq 0x1269(%rip), %rdi      # 0x4292
leaq 0x126a(%rip), %rsi      # 0x429a
movl $0x14, %edx
leaq 0x1271(%rip), %rcx      # 0x42ad
callq 0x2120
jmp 0x3043
cmpq $0x0, -0x1020(%rbp)
jbe 0x30ae
movl -0x1014(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20c0
movl %eax, -0x1024(%rbp)
cmpl $0x0, -0x1024(%rbp)
jle 0x3075
jmp 0x3094
leaq 0x1256(%rip), %rdi      # 0x42d2
leaq 0x1217(%rip), %rsi      # 0x429a
movl $0x18, %edx
leaq 0x121e(%rip), %rcx      # 0x42ad
callq 0x2120
movslq -0x1024(%rbp), %rcx
movq -0x1020(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x1020(%rbp)
jmp 0x3043
movl -0x1014(%rbp), %edi
callq 0x2140
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/writeseek3.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	int fd = open(tmpfile, O_RDWR);
	unsigned long offset = getpagesize() * nr;

	assert(fd >= 0);

	while (1) {
		lseek(fd, offset, SEEK_SET);
		assert(write(fd, buf, BUFLEN) == BUFLEN);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x30b6(%rip), %rdi      # 0x61a0
movl $0x2, %esi
movb $0x0, %al
callq 0x2210
movl %eax, -0x1014(%rbp)
callq 0x2280
cltq
imulq -0x10(%rbp), %rax
movq %rax, -0x1020(%rbp)
cmpl $0x0, -0x1014(%rbp)
jl 0x311a
jmp 0x3139
leaq 0x1171(%rip), %rdi      # 0x4292
leaq 0x1172(%rip), %rsi      # 0x429a
movl $0x24, %edx
leaq 0x11a4(%rip), %rcx      # 0x42d8
callq 0x2120
jmp 0x313b
movl -0x1014(%rbp), %edi
movq -0x1020(%rbp), %rsi
xorl %edx, %edx
callq 0x2110
movl -0x1014(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20c0
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x3170
jmp 0x318f
leaq 0x1194(%rip), %rdi      # 0x430b
leaq 0x111c(%rip), %rsi      # 0x429a
movl $0x28, %edx
leaq 0x114e(%rip), %rcx      # 0x42d8
callq 0x2120
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x313b
nop
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/PantoulasStefanosProject2/trie/input_parse.c
// Function: read_doc
int read_doc(char *name,char ***map,int *lines){
	char c,pr_c;
	FILE* fp;
	*lines = 0;
	int counter = 0;//byte counter here
	if((fp=fopen(name,"r"))==NULL){
		printf("Given file doesn't exists!\n");
		return -1;
	}
	if(fp == NULL ){fclose(fp); return -1;}//error
	while((c=getc(fp)) != EOF){//1st parsing to find the lines
		if(c == '\n' && pr_c != '\n') (*lines)++;
		pr_c = c;
	}
	if(!(*lines)){printf("Empty input file!\n");fclose(fp);return -2;}
	//printf("Read %d folders!\n",*lines);
	*map = malloc((*lines)*sizeof(char*));
	if(fseek(fp,0L,SEEK_SET) !=0) {fclose(fp); return -2;}
	for(int i=0;i<(*lines);i++){
		fscanf(fp,"%m[^\n]s",&(*map)[i]);//read and save line
		getc(fp);//skip the remaining '\n'
		counter += strlen((*map)[i]) + 1;//the '+1' for '\n'
	}
	fclose(fp);
	return counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6dd2(%rip), %rsi      # 0x8202
callq 0x1250
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x1459
leaq 0x6bbe(%rip), %rdi      # 0x8004
movb $0x0, %al
callq 0x1120
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x159a
cmpq $0x0, -0x30(%rbp)
jne 0x1475
movq -0x30(%rbp), %rdi
callq 0x10f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x159a
jmp 0x1477
movq -0x30(%rbp), %rdi
callq 0x12e0
movb %al, -0x21(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x14b0
movsbl -0x21(%rbp), %eax
cmpl $0xa, %eax
jne 0x14a8
movsbl -0x22(%rbp), %eax
cmpl $0xa, %eax
je 0x14a8
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb -0x21(%rbp), %al
movb %al, -0x22(%rbp)
jmp 0x1477
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x14dc
leaq 0x6b60(%rip), %rdi      # 0x8020
movb $0x0, %al
callq 0x1120
movq -0x30(%rbp), %rdi
callq 0x10f0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x159a
movq -0x20(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x11e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x11f0
cmpl $0x0, %eax
je 0x151c
movq -0x30(%rbp), %rdi
callq 0x10f0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x159a
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x158b
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movslq -0x38(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
leaq 0x6ae8(%rip), %rsi      # 0x8033
movb $0x0, %al
callq 0x1090
movq -0x30(%rbp), %rdi
callq 0x12e0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1110
movq %rax, %rcx
addq $0x1, %rcx
movslq -0x34(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1523
movq -0x30(%rbp), %rdi
callq 0x10f0
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/PantoulasStefanosProject2/trie/postingList.c
// Function: ePostingListConstuct
ePostingList* ePostingListConstuct(){
	ePostingList* epl = malloc(sizeof(ePostingList));
	epl->counter=0;
	epl->pl = NULL;
	epl->last=NULL;
	return epl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x11e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/PantoulasStefanosProject2/trie/postingList.c
// Function: ePostingListDestruct
void ePostingListDestruct(ePostingList* self){
	if(self==NULL) return;
	postingList1Destruct(self->pl);
	self->last = NULL;
	free(self);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1935
jmp 0x1957
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1960
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/PantoulasStefanosProject2/trie/postingList.c
// Function: postingList1Destruct
void postingList1Destruct(postingList1* self){//recursive destruction
	if(self==NULL) return;
	postingList2Destruct(self->pl);
	postingList1Destruct(self->next);
	self->name = NULL;
	self->last = NULL;
	free(self);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1975
jmp 0x19b0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x19c0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1960
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/PantoulasStefanosProject2/trie/postingList.c
// Function: postingList2Destruct
void postingList2Destruct(postingList2* self){
	if(self==NULL) return;
	postingList2Destruct(self->next);
	free(self);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x19d5
jmp 0x19eb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x19c0
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/PantoulasStefanosProject2/trie/postingList.c
// Function: insertInPL2
postingList2* insertInPL2(int line){
	postingList2* pl = malloc(sizeof(postingList2));
	pl->line = line;
	pl->next = NULL;
	return pl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, %edi
callq 0x11e0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/PantoulasStefanosProject2/trie/postingList.c
// Function: insertInPL
postingList1* insertInPL(int line,char* name,int id){//creates new pl's node
	postingList1* pl = malloc(sizeof(postingList1));
	pl->name = name;//just point to real name
	pl->id = id;
	pl->counter=1;
	pl->linecounter=1;
	pl->next=NULL;
	pl->pl = insertInPL2(line);
	pl->last = pl->pl;
	return pl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x30, %edi
callq 0x11e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movl -0x4(%rbp), %edi
callq 0x1a00
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/PantoulasStefanosProject2/trie/postingList.c
// Function: getMaxCounter
void getMaxCounter(ePostingList *self,char **name,int *counter){
	postingList1 *temp = self->pl;
	*name = temp->name;
	*counter = temp->counter;
	while((temp = temp->next) != NULL){
		if(temp->counter>*counter || (temp->counter==*counter && strcmp(temp->name,*name)<0)){
			*name = temp->name;
			*counter = temp->counter;
		}
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1b6f
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x1b52
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1b6d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1160
cmpl $0x0, %eax
jge 0x1b6d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1b0b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/PantoulasStefanosProject2/trie/postingList.c
// Function: updatePL
void updatePL(ePostingList **self,int line,char *name,int id){
	if((*self)->pl==NULL){
		(*self)->pl=insertInPL(line,name,id);
		(*self)->last = (*self)->pl;
		(*self)->counter++;//new PL node
		return;
	}
	postingList1 *temp = (*self)->last;
	if(!strcmp(temp->name,name) && (temp->last)->line>line){//that will never happen :-)
		printf("You shouldn't come here,leave me alone ~_~'\n");
		return ;
	}
	//checking name or id is the same in PL
	if(!strcmp(temp->name,name)){//now lets check pl2
		temp->counter++;//increase counter for the file
		if((temp->last)->line == line){}//do nothing
			//(temp->last)->freq++;//freq deleted
		else{//new line,create next pl2
			temp->linecounter++;
			(temp->last)->next = insertInPL2(line);
			((*self)->last)->last = (temp->last)->next;
		}
		return;
	}
	temp->next = insertInPL(line,name,id);
	(*self)->last = temp->next;
	(*self)->counter++;//new PL node
	return ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1caa
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x1a40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x1d9f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1160
cmpl $0x0, %eax
jne 0x1cf1
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x1cf1
leaq 0x642f(%rip), %rdi      # 0x8114
movb $0x0, %al
callq 0x1120
jmp 0x1d9f
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1160
cmpl $0x0, %eax
jne 0x1d64
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x1d23
jmp 0x1d62
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %edi
callq 0x1a00
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x28(%rax)
jmp 0x1d9f
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x1a40
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stefpant[P]TCPserver/PantoulasStefanosProject2/trie/postingList.c
// Function: replaceSpaces
void replaceSpaces(char** str){
	if(str == NULL) return;
	int len;
	if((len = strlen(*str)) == 0) return;
	for(int i=0;i<len;i++)
		if((*str)[i] == ' ') (*str)[i]='_';
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1dc5
jmp 0x1e1c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1110
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jne 0x1ddb
jmp 0x1e1c
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1e1a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x1e0d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movb $0x5f, (%rax,%rcx)
jmp 0x1e0f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1de2
jmp 0x1e1c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)