LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/string/ft_strcpy.c
// Function: ft_strcpy
char	*ft_strcpy(char *dst, const char *src)
{
	size_t	i;

	i = 0;
	while (src[i])
	{
		dst[i] = src[i];
		i++;
	}
	dst[i] = '\0';
	return (dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x9c56
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9c24
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripmime.c
// Function: RIPMIME_report_filename_decoded
int RIPMIME_report_filename_decoded (char *filename, char *contenttype)
{
   char *p;

   p = strrchr(filename,'/');
   if (!p) p = filename; else p++;

   if (contenttype != NULL)
   {
       LOGGER_log ("Decoding content-type=%s filename=%s", contenttype, p);
   }
   else
   {
       LOGGER_log ("Decoding filename=%s", p);
   }

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x2140
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2503
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x250f
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x252e
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x16c07(%rip), %rdi     # 0x1912c
movb $0x0, %al
callq 0x117c0
jmp 0x2540
movq -0x18(%rbp), %rsi
leaq 0x16c18(%rip), %rdi     # 0x19151
movb $0x0, %al
callq 0x117c0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripmime.c
// Function: RIPMIME_init
int RIPMIME_init (struct RIPMIME_globals *glb)
{
   glb->dir = defaultdir;
   glb->inputfile = NULL;
   glb->use_return_codes = 0;
   glb->timeout = 0;
   glb->quiet = 0;
   glb->verbose_defects = 0;
   glb->verbose = 0;

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x22fbd(%rip), %rcx     # 0x26200
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripmime.c
// Function: RIPMIME_unpack_single
int RIPMIME_unpack_single( struct RIPMIME_globals *glb, char *fname )
{
   int result = 0;

   /** Set the alarm timeout feature. **/
   if (glb->timeout > 0) {
       signal(SIGALRM, RIPMIME_signal_alarm);
       alarm(glb->timeout);
   }

   MIMEH_set_outputdir (glb->dir);
   result = MIME_unpack (glb->dir, fname, 0);

   // do any last minute things

   MIME_close ();

   return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jle 0x332e
movl $0xe, %edi
leaq -0x8d(%rip), %rsi       # 0x3290
callq 0x21f0
movq -0x8(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x2170
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa440
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x62e0
movl %eax, -0x14(%rbp)
callq 0x9470
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/strstack.c
// Function: SS_init
int SS_init( struct SS_object *ss )
{
	ss->debug = 0;
	ss->verbose = 0;
	ss->count = 0;
	ss->stringstack = NULL;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/strstack.c
// Function: SS_done
int SS_done( struct SS_object *ss )
{
	struct SS_node *next;

	while ((ss->stringstack != NULL)&&(ss->count > 0))
	{
		DSS LOGGER_log("%s:%d:SS_done: Popping off %s",FL,ss->stringstack->data);
		next = ss->stringstack->next;
		free(ss->stringstack->data);
		free(ss->stringstack);
		ss->stringstack = next;
		ss->count--;
	}

	ss->stringstack = NULL;
	ss->count = 0;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x10(%rcx)
movb %al, -0x11(%rbp)
je 0x37ea
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
setg %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x37f3
jmp 0x386c
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3821
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
leaq 0x15d61(%rip), %rdi     # 0x1956f
leaq 0x15d78(%rip), %rsi     # 0x1958d
movl $0x6c, %edx
movb $0x0, %al
callq 0x117c0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x37cc
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/strstack.c
// Function: SS_dump
int SS_dump( struct SS_object *ss )
{
	struct SS_node *n = ss->stringstack;

	while (n != NULL)
	{
		LOGGER_log("%s",n->data);
		n = n->next;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x38d2
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x1b6ed(%rip), %rdi     # 0x1efaa
movb $0x0, %al
callq 0x117c0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x38a8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/strstack.c
// Function: SS_push
int SS_push( struct SS_object *ss, char *data, size_t data_length )
{

	struct SS_node *node = malloc(sizeof(struct SS_node));


	if (node)
	{
		DSS LOGGER_log("%s:%d:SS_push: Pushing %s to %p, stack count = %d",FL,data, ss->stringstack, ss->count);
		node->next = ss->stringstack;
		ss->stringstack = node;
		ss->stringstack->data = strdup(data);
		ss->stringstack->data_length = data_length;
		ss->count++;
	}
	else
	    {
		LOGGER_log("%s:%d:SS_push:ERROR: Cannot allocate memory for string stack PUSH, %s", FL, strerror(errno));
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x2290
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3996
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3944
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %r8
movq -0x8(%rbp), %rax
movl 0x8(%rax), %r9d
leaq 0x15c67(%rip), %rdi     # 0x19598
leaq 0x15c55(%rip), %rsi     # 0x1958d
movl $0xaf, %edx
movb $0x0, %al
callq 0x117c0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x2390
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x39bf
callq 0x2050
movl (%rax), %edi
callq 0x23a0
movq %rax, %rcx
leaq 0x15c1e(%rip), %rdi     # 0x195ca
leaq 0x15bda(%rip), %rsi     # 0x1958d
movl $0xb8, %edx
movb $0x0, %al
callq 0x117c0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/strstack.c
// Function: SS_pop
char *SS_pop( struct SS_object *ss )
{

	struct SS_node *node = ss->stringstack;

	if ((ss->stringstack)&&(ss->count > 0))
	{
		ss->stringstack = ss->stringstack->next;
		PLD_strncpy(ss->datastacksafe,node->data, SS_STRLEN_MAX);
		free(node->data);
		free(node);
		ss->count--;
	} else return NULL;

	return ss->datastacksafe;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3a4e
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x3a4e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x10640
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x3a58
movq $0x0, -0x8(%rbp)
jmp 0x3a64
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/strstack.c
// Function: SS_cmp
char *SS_cmp( struct SS_object *ss, char *find_me, size_t find_me_len )
{
	struct SS_node *n = ss->stringstack;
	int hit=0;

	while ((n != NULL)&&(hit == 0))
	{
		if (strncmp(find_me, n->data, find_me_len) == 0) hit++;
		if (hit == 0) n = n->next;
	}

	if (hit == 0) return NULL;
	else return n->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x2d(%rbp)
je 0x3b0d
cmpl $0x0, -0x2c(%rbp)
sete %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x3b16
jmp 0x3b4c
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2090
cmpl $0x0, %eax
jne 0x3b38
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x3b4a
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3af7
cmpl $0x0, -0x2c(%rbp)
jne 0x3b5c
movq $0x0, -0x8(%rbp)
jmp 0x3b67
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: MIME_version
int MIME_version( void )
{
    fprintf(stderr,"ripMIME: %s\n", LIBMIME_VERSION);
    MIMEH_version();
#ifdef RIPOLE
    OLE_version();
#endif

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2246d(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
leaq 0x15a7b(%rip), %rsi     # 0x19610
leaq 0x15a81(%rip), %rdx     # 0x1961d
movb $0x0, %al
callq 0x2200
callq 0xa270
callq 0x14830
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: MIME_set_debug
int MIME_set_debug( int level )
{
    glb.debug = level;

    BS_set_debug(level);
    TNEF_set_debug(level);
    MIMEH_set_debug(level);
    MDECODE_set_debug(level);
    UUENCODE_set_debug(level);
    FNFILTER_set_debug(level);
    return glb.debug;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x23afc(%rip)     # 0x276f0
movl -0x4(%rbp), %edi
callq 0x127b0
movl -0x4(%rbp), %edi
callq 0xf080
movl -0x4(%rbp), %edi
callq 0xa420
movl -0x4(%rbp), %edi
callq 0x11aa0
movl -0x4(%rbp), %edi
callq 0x130e0
movl -0x4(%rbp), %edi
callq 0x14250
movl 0x23ac6(%rip), %eax     # 0x276f0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: MIME_set_quiet
int MIME_set_quiet( int level )
{
    glb.quiet = level;
    MIME_set_debug(0);
    MIME_set_verbosity(0);
    return glb.quiet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x23ab0(%rip)     # 0x276f4
xorl %edi, %edi
callq 0x3be0
xorl %edi, %edi
callq 0x3c60
movl 0x23a9c(%rip), %eax     # 0x276f4
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: MIME_set_verbosity
int MIME_set_verbosity( int level )
{
    glb.verbosity = level;
    MIMEH_set_verbosity( level );
    TNEF_set_verbosity( level );
    FNFILTER_set_verbose( level );
    UUENCODE_set_verbosity( level );
    MDECODE_set_verbose( level );
    BS_set_verbose( level );
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x23a68(%rip)     # 0x276dc
movl -0x4(%rbp), %edi
callq 0xa4c0
movl -0x4(%rbp), %edi
callq 0xf020
movl -0x4(%rbp), %edi
callq 0x14270
movl -0x4(%rbp), %edi
callq 0x13100
movl -0x4(%rbp), %edi
callq 0x11ac0
movl -0x4(%rbp), %edi
callq 0x12790
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: MIME_set_verbosity_contenttype
int MIME_set_verbosity_contenttype( int level )
{
    glb.verbosity_contenttype = level;
    MIMEH_set_verbosity_contenttype( level );
    UUENCODE_set_verbosity_contenttype( level );
    TNEF_set_verbosity_contenttype( level );
    return glb.verbosity_contenttype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x23810(%rip)     # 0x276e4
movl -0x4(%rbp), %edi
callq 0xa4e0
movl -0x4(%rbp), %edi
callq 0x13120
movl -0x4(%rbp), %edi
callq 0xf040
movl 0x237f2(%rip), %eax     # 0x276e4
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: MIME_set_filename_report_fn
int MIME_set_filename_report_fn( int (*ptr_to_fn)(char *, char *) )
{
    glb.filename_decoded_reporter = ptr_to_fn;
    UUENCODE_set_filename_report_fn( ptr_to_fn );
    TNEF_set_filename_report_fn( ptr_to_fn );

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x267f1(%rip)     # 0x2a748
movq -0x8(%rbp), %rdi
callq 0x13180
movq -0x8(%rbp), %rdi
callq 0xf060
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: MIME_set_renamemethod
int MIME_set_renamemethod( int method )
{
    if (( method >= _MIME_RENAME_METHOD_INFIX ) && ( method <= _MIME_RENAME_METHOD_RANDPOSTFIX ))
    {
        glb.rename_method = method;
    }
    else
    {
        LOGGER_log("%s:%d:MIME_set_renamemethod:ERROR: selected method not within %d > x > %d range", FL, _MIME_RENAME_METHOD_INFIX, _MIME_RENAME_METHOD_POSTFIX );
        return -1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x1, -0x8(%rbp)
jl 0x40e2
cmpl $0x6, -0x8(%rbp)
jg 0x40e2
movl -0x8(%rbp), %eax
movl %eax, 0x23624(%rip)     # 0x27704
jmp 0x4110
leaq 0x15541(%rip), %rdi     # 0x1962a
leaq 0x153df(%rip), %rsi     # 0x194cf
movl $0x380, %edx            # imm = 0x380
movl $0x1, %ecx
movl $0x3, %r8d
movb $0x0, %al
callq 0x117c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4117
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: get_random_value
int get_random_value(void) {
    int randval;
    FILE *fp;
    fp = fopen("/dev/urandom", "r");
    fread(&randval, sizeof(randval), 1, fp);
    fclose(fp);
    if (randval < 0) { randval = randval *( -1); };
    return randval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1552b(%rip), %rdi     # 0x1967a
leaq 0x1953e(%rip), %rsi     # 0x1d694
callq 0x2330
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x4(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x20b0
movq -0x10(%rbp), %rdi
callq 0x20e0
cmpl $0x0, -0x4(%rbp)
jge 0x418c
imull $-0x1, -0x4(%rbp), %eax
movl %eax, -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/mime.c
// Function: MIME_getchar_start
int MIME_getchar_start( FFGET_FILE *f )
{
    int c;
    /* loop for eternity, as we're "returning out" */
    while (1)
    {
        /* get a single char from file */
        c = FFGET_fgetc(f);
        /* if that char is an EOF, or the char is something beyond
         * ASCII 32 (space) then return */
        if ((c == EOF) || (c > ' '))
        {
            return c;
        }
    } /* while */
    /* Although we shouldn't ever actually get here, we best put it in anyhow */
    return EOF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x99f0
movsbl %al, %eax
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x4957
cmpl $0x20, -0xc(%rbp)
jle 0x4960
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
jmp 0x493c
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: MIME_decode_TNEF
int MIME_decode_TNEF( char *unpackdir, struct MIMEH_header_info *hinfo, int keep )
{
    int result=0;
    char fullpath[1024];

    snprintf(fullpath,sizeof(fullpath),"%s/%s",unpackdir,hinfo->filename);
    TNEF_set_path(unpackdir);
    result = TNEF_main( fullpath );

    if (result >= 0)
    {
        //      result = remove( fullpath );
        if (result == -1)
        {
            if (MIME_VERBOSE) LOGGER_log("%s:%d:MIME_decode_TNEF: Removing %s failed (%s)",FL,fullpath,strerror(errno));
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x420(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
addq $0x5efd, %r8            # imm = 0x5EFD
movl $0x400, %esi            # imm = 0x400
leaq 0x14b4d(%rip), %rdx     # 0x194fc
movb $0x0, %al
callq 0x2130
movq -0x8(%rbp), %rdi
callq 0xefe0
leaq -0x420(%rbp), %rdi
callq 0x101c0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x4a25
cmpl $-0x1, -0x18(%rbp)
jne 0x4a23
cmpl $0x0, 0x22cfb(%rip)     # 0x276dc
jle 0x4a21
leaq -0x420(%rbp), %rax
movq %rax, -0x428(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x23a0
movq -0x428(%rbp), %rcx
movq %rax, %r8
leaq 0x14ebd(%rip), %rdi     # 0x198cb
leaq 0x14aba(%rip), %rsi     # 0x194cf
movl $0x49b, %edx            # imm = 0x49B
movb $0x0, %al
callq 0x117c0
jmp 0x4a23
jmp 0x4a25
movl -0x18(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: MIME_decode_OLE
int MIME_decode_OLE( char *unpackdir, struct MIMEH_header_info *hinfo, int keep )
{
    struct OLE_object ole;
    char fullpath[1024];
    int result;

    snprintf(fullpath,sizeof(fullpath),"%s/%s",unpackdir,hinfo->filename);

    OLE_init(&ole);
    OLE_set_quiet(&ole,glb.quiet);
    OLE_set_verbose(&ole,glb.verbosity);
    OLE_set_debug(&ole,glb.debug);
    OLE_set_save_unknown_streams(&ole,0);
    OLE_set_filename_report_fn(&ole, MIME_report_filename_decoded_RIPOLE );

    if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_OLE:DEBUG: Starting OLE Decode",FL);
    result = OLE_decode_file(&ole, fullpath, unpackdir );
    if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_OLE:DEBUG: Decode done, cleaning up.",FL);
    OLE_decode_file_done(&ole);

    if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_decode_OLE:DEBUG: Decode returned with code = %d",FL,result);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8a0, %rsp            # imm = 0x8A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x890(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
addq $0x5efd, %r8            # imm = 0x5EFD
movl $0x400, %esi            # imm = 0x400
leaq 0x14a54(%rip), %rdx     # 0x194fc
movb $0x0, %al
callq 0x2130
leaq -0x490(%rbp), %rdi
callq 0x14860
movl 0x22c33(%rip), %esi     # 0x276f4
leaq -0x490(%rbp), %rdi
callq 0x149f0
movl 0x22c09(%rip), %esi     # 0x276dc
leaq -0x490(%rbp), %rdi
callq 0x149d0
movl 0x22c0b(%rip), %esi     # 0x276f0
leaq -0x490(%rbp), %rdi
callq 0x14a30
leaq -0x490(%rbp), %rdi
xorl %esi, %esi
callq 0x14a90
leaq -0x490(%rbp), %rdi
leaq -0xcd(%rip), %rsi       # 0x4a40
callq 0x16890
cmpl $0x1, 0x22bd7(%rip)     # 0x276f0
jl 0x4b35
leaq 0x14dd9(%rip), %rdi     # 0x198fb
leaq 0x149a6(%rip), %rsi     # 0x194cf
movl $0x4c8, %edx            # imm = 0x4C8
movb $0x0, %al
callq 0x117c0
leaq -0x890(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x490(%rbp), %rdi
callq 0x16f30
movl %eax, -0x894(%rbp)
cmpl $0x1, 0x22b97(%rip)     # 0x276f0
jl 0x4b75
leaq 0x14dca(%rip), %rdi     # 0x1992c
leaq 0x14966(%rip), %rsi     # 0x194cf
movl $0x4ca, %edx            # imm = 0x4CA
movb $0x0, %al
callq 0x117c0
leaq -0x490(%rbp), %rdi
callq 0x16a40
cmpl $0x1, 0x22b68(%rip)     # 0x276f0
jl 0x4baa
movl -0x894(%rbp), %ecx
leaq 0x14dcc(%rip), %rdi     # 0x19963
leaq 0x14931(%rip), %rsi     # 0x194cf
movl $0x4cd, %edx            # imm = 0x4CD
movb $0x0, %al
callq 0x117c0
movl -0x894(%rbp), %eax
addq $0x8a0, %rsp            # imm = 0x8A0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: MIME_decode_64_cleanup
int MIME_decode_64_cleanup( FFGET_FILE *f, char *unpackdir, struct MIMEH_header_info *hinfo)
{
    int result = 0;
    char buffer[128];

    while (FFGET_fgets(buffer, sizeof(buffer), f))
    {
        if (FFGET_feof(f) != 0) break;
        if (BS_cmp(buffer,strlen(buffer)) > 0) break;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x80, %esi
callq 0x9ab0
cmpq $0x0, %rax
je 0x611a
movq -0x8(%rbp), %rdi
callq 0x98c0
cmpl $0x0, %eax
je 0x60e9
jmp 0x611a
leaq -0xa0(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x2100
movq -0xa8(%rbp), %rdi
movl %eax, %esi
callq 0x12d80
cmpl $0x0, %eax
jle 0x6118
jmp 0x611a
jmp 0x60be
movl -0x1c(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: MIME_init
int MIME_init( void )
{

    BS_init();          // Boundary-stack initialisations
    MIMEH_init();       // Initialise MIME header routines.
    UUENCODE_init();    // uuen:coding decoding initialisations
    FNFILTER_init();    // Filename filtering
    MDECODE_init(); // ISO filename decoding initialisation
    TNEF_init();        // TNEF decoder


    glb.header_defect_count = 0;
    glb.filecount = 0;
    glb.attachment_count = 0;
    glb.current_line = 0;
    glb.verbosity = 0;
    glb.verbose_defects = 0;
    glb.debug = 0;
    glb.quiet = 0;
    glb.syslogging = 0;
    glb.stderrlogging = 1;
    glb.unique_names = 0;
    glb.save_headers = 0;
    glb.no_nameless = 0;
    glb.mailbox_format = 0;
    glb.name_by_type = 0;
    glb.rename_method = _MIME_RENAME_METHOD_INFIX;

    glb.header_longsearch = 0;
    glb.max_recursion_level = _RECURSION_LEVEL_DEFAULT;

    glb.decode_qp = 1;
    glb.decode_b64 = 1;
    glb.decode_tnef = 1;
    glb.decode_ole = 1;
    glb.decode_uu = 1;
    glb.decode_mht = 1;

    glb.multiple_filenames = 1;

    glb.blankzone_save_option = MIME_BLANKZONE_SAVE_TEXTFILE;
    glb.blankzone_saved = 0;

    snprintf( glb.headersname, sizeof(glb.headersname), "_headers_" );
    snprintf( glb.blankfileprefix, sizeof( glb.blankfileprefix ), "textfile" );
    glb.blankfileprefix_expliticly_set = 0;

    glb.subject[0]='\0';

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x12700
callq 0xa2a0
callq 0x130a0
callq 0x14220
callq 0x11a70
callq 0xef60
movl $0x0, 0x20934(%rip)     # 0x272d0
movl $0x0, 0x2092e(%rip)     # 0x272d4
movl $0x0, 0x2155c(%rip)     # 0x27f0c
movl $0x0, 0x21556(%rip)     # 0x27f10
movl $0x0, 0x20d18(%rip)     # 0x276dc
movl $0x0, 0x20d1a(%rip)     # 0x276e8
movl $0x0, 0x20d18(%rip)     # 0x276f0
movl $0x0, 0x20d12(%rip)     # 0x276f4
movl $0x0, 0x20d0c(%rip)     # 0x276f8
movl $0x1, 0x20d06(%rip)     # 0x276fc
movl $0x0, 0x20d00(%rip)     # 0x27700
movl $0x0, 0x214fe(%rip)     # 0x27f08
movl $0x0, 0x21500(%rip)     # 0x27f14
movl $0x0, 0x214fe(%rip)     # 0x27f1c
movl $0x0, 0x214f0(%rip)     # 0x27f18
movl $0x1, 0x20cd2(%rip)     # 0x27704
movl $0x0, 0x21500(%rip)     # 0x27f3c
movl $0x14, 0x214fa(%rip)    # 0x27f40
movl $0x1, 0x214dc(%rip)     # 0x27f2c
movl $0x1, 0x214ce(%rip)     # 0x27f28
movl $0x1, 0x214c0(%rip)     # 0x27f24
movl $0x1, 0x214c6(%rip)     # 0x27f34
movl $0x1, 0x214a8(%rip)     # 0x27f20
movl $0x1, 0x214ae(%rip)     # 0x27f30
movl $0x1, 0x214ac(%rip)     # 0x27f38
movl $0x4, 0x214b2(%rip)     # 0x27f48
movl $0x0, 0x214a4(%rip)     # 0x27f44
leaq 0x20829(%rip), %rdi     # 0x272d0
addq $0x438, %rdi            # imm = 0x438
movl $0x3ff, %esi            # imm = 0x3FF
leaq 0x13d64(%rip), %rdx     # 0x1a81e
movb $0x0, %al
callq 0x2130
leaq 0x20808(%rip), %rdi     # 0x272d0
addq $0x8, %rdi
movl $0x3ff, %esi            # imm = 0x3FF
leaq 0x13d50(%rip), %rdx     # 0x1a828
movb $0x0, %al
callq 0x2130
movl $0x0, 0x20bef(%rip)     # 0x276d8
movb $0x0, 0x23c60(%rip)     # 0x2a750
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: MIME_postdecode_cleanup
int MIME_postdecode_cleanup( char *unpackdir, struct SS_object *ss )
{
    char fullpath[256];
    int result;
    result = 0;
    do {
        char *filename;
        if (MIME_DNORMAL) LOGGER_log("%s:%d: Popping file...",FL);
        filename = SS_pop(ss);
        if (filename == NULL) break;
        if (MIME_DNORMAL) LOGGER_log("%s:%d: Popped file '%s'",FL, filename);
        if ( strncmp( glb.blankfileprefix, filename, strlen( glb.blankfileprefix ) ) == 0 )
        {
            snprintf( fullpath, sizeof(fullpath), "%s/%s", unpackdir, filename );
            result = unlink( fullpath );
            if (MIME_VERBOSE)
            {
                if (result == -1) LOGGER_log("Error removing '%s'; %s", fullpath, strerror(errno));
                else LOGGER_log("Removed %s [status = %d]\n", fullpath, result );
            }
        }
    } while (1);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x114(%rbp)
cmpl $0x1, 0x1fbec(%rip)     # 0x276f0
jl 0x7b20
leaq 0x132fb(%rip), %rdi     # 0x1ae08
leaq 0x119bb(%rip), %rsi     # 0x194cf
movl $0x9cb, %edx            # imm = 0x9CB
movb $0x0, %al
callq 0x117c0
movq -0x10(%rbp), %rdi
callq 0x39d0
movq %rax, -0x120(%rbp)
cmpq $0x0, -0x120(%rbp)
jne 0x7b3f
jmp 0x7c50
cmpl $0x1, 0x1fbaa(%rip)     # 0x276f0
jl 0x7b69
movq -0x120(%rbp), %rcx
leaq 0x132c9(%rip), %rdi     # 0x1ae1f
leaq 0x11972(%rip), %rsi     # 0x194cf
movl $0x9ce, %edx            # imm = 0x9CE
movb $0x0, %al
callq 0x117c0
movq -0x120(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq 0x1f75a(%rip), %rdi     # 0x272d8
callq 0x2100
movq -0x128(%rbp), %rsi
movq %rax, %rdx
leaq 0x1f73c(%rip), %rdi     # 0x272d0
addq $0x8, %rdi
callq 0x2090
cmpl $0x0, %eax
jne 0x7c42
leaq -0x110(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq -0x120(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0x11938(%rip), %rdx     # 0x194fc
movb $0x0, %al
callq 0x2130
leaq -0x110(%rbp), %rdi
callq 0x2060
movl %eax, -0x114(%rbp)
cmpl $0x0, 0x1faf8(%rip)     # 0x276dc
jle 0x7c40
cmpl $-0x1, -0x114(%rbp)
jne 0x7c23
leaq -0x110(%rbp), %rax
movq %rax, -0x130(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x23a0
movq -0x130(%rbp), %rsi
movq %rax, %rdx
leaq 0x1321d(%rip), %rdi     # 0x1ae37
movb $0x0, %al
callq 0x117c0
jmp 0x7c3e
leaq -0x110(%rbp), %rsi
movl -0x114(%rbp), %edx
leaq 0x13218(%rip), %rdi     # 0x1ae4f
movb $0x0, %al
callq 0x117c0
jmp 0x7c40
jmp 0x7c42
jmp 0x7c44
movb $0x1, %al
testb $0x1, %al
jne 0x7afd
jmp 0x7c50
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/mime.c
// Function: MIME_handle_plain
int MIME_handle_plain( FFGET_FILE *f, char *unpackdir, struct MIMEH_header_info *h, int current_recursion_level, struct SS_object *ss )
{
    /** Handle a plain text encoded data stream from *f **/
    int result = 0;
    if (MIME_DNORMAL) LOGGER_log("%s:%d:MIME_handle_plain:DEBUG: Handling plain email",FL);
    result = MIME_decode_encoding( f, unpackdir, h, ss );
    if ((result == MIME_ERROR_FFGET_EMPTY)||(result == 0))
    {
        /** Test for RFC822 content... if so, go decode it **/
        snprintf(h->scratch,sizeof(h->scratch),"%s/%s",unpackdir,h->filename);
        if (MIME_is_file_RFC822(h->scratch)==1)
        {
            /** If the file is RFC822, then decode it using MIME_unpack_single() **/
            if (glb.header_longsearch != 0) MIMEH_set_header_longsearch(glb.header_longsearch);
            result = MIME_unpack_single( unpackdir, h->scratch, current_recursion_level, ss );
            if (glb.header_longsearch != 0) MIMEH_set_header_longsearch(0);
        }
    }
    return result;
}

// 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 %r8, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x1, 0x1eb37(%rip)     # 0x276f0
jl 0x8bd5
leaq 0x125c6(%rip), %rdi     # 0x1b188
leaq 0x10906(%rip), %rsi     # 0x194cf
movl $0xa79, %edx            # imm = 0xA79
movb $0x0, %al
callq 0x117c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6e60
movl %eax, -0x2c(%rbp)
cmpl $0xf1, -0x2c(%rbp)
je 0x8bfc
cmpl $0x0, -0x2c(%rbp)
jne 0x8c6f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
addq $0x5efd, %r8            # imm = 0x5EFD
movl $0x27f7, %esi           # imm = 0x27F7
leaq 0x108e1(%rip), %rdx     # 0x194fc
movb $0x0, %al
callq 0x2130
movq -0x18(%rbp), %rdi
callq 0x4580
cmpl $0x1, %eax
jne 0x8c6d
cmpl $0x0, 0x1f305(%rip)     # 0x27f3c
je 0x8c44
movl 0x1f2fd(%rip), %edi     # 0x27f3c
callq 0xa5f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x78b0
movl %eax, -0x2c(%rbp)
cmpl $0x0, 0x1f2da(%rip)     # 0x27f3c
je 0x8c6b
xorl %edi, %edi
callq 0xa5f0
jmp 0x8c6d
jmp 0x8c6f
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ffget.c
// Function: FFGET_presetbuffer
int FFGET_presetbuffer( FFGET_FILE *f, char *buffer, int size )
{
	if (size > FFGET_BUFFER_MAX) size = FFGET_BUFFER_MAX;

	memcpy(f->buffer,buffer,size);
	f->startpoint = buffer;
	f->endpoint = buffer +size;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x2000, -0x14(%rbp)    # imm = 0x2000
jle 0x9713
movl $0x2000, -0x14(%rbp)    # imm = 0x2000
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2250
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2010(%rax)
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2018(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ffget.c
// Function: FFGET_setstream
int FFGET_setstream( FFGET_FILE *f, FILE *fi )
{

//	memset(f,0,sizeof(FFGET_FILE)); // be pedantic - clear the struct

	f->f = fi;
	f->bytes = 0;
	f->linecount = 0;
	f->endpoint = f->buffer;
	f->startpoint = f->endpoint +1;
	f->buffer_end = f->buffer +FFGET_BUFFER_MAX +FFGET_BUFFER_PADDING;
	f->trueblank = 0;
	f->ungetcset = 0;
	f->lastchar = '\0';
	memset(f->buffer,'\0',FFGET_BUFFER_MAX +FFGET_BUFFER_PADDING);
	f->c = '\0';
	f->FFEOF = 0;
	f->FILEEND = 0;
	f->last_block_read_from = -1;
	f->linebreak = FFGET_LINEBREAK_NONE;
	f->lastbreak[0] = '\0';
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x2040(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x2048(%rax)
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2018(%rax)
movq -0x8(%rbp), %rax
movq 0x2018(%rax), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2010(%rax)
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
addq $0x2000, %rcx           # imm = 0x2000
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2020(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2054(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2050(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x2058(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x2001, %edx           # imm = 0x2001
callq 0x2150
movq -0x8(%rbp), %rax
movb $0x0, 0x2038(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2034(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2030(%rax)
movq -0x8(%rbp), %rax
movq $-0x1, 0x2028(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x205c(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x2060(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ffget.c
// Function: FFGET_seek
int FFGET_seek( FFGET_FILE *f, long offset, int whence )
{
	int result = 0;

	/** Move to the new block location **/
	result = fseek(f->f, offset, whence);
	if (result == -1) {
		LOGGER_log("%s:%d:FFGET_seek:ERROR: While attempting to seek to offset %ld from %d - [%s]", FL, offset, whence, strerror(errno));
		return -1;
	}

	/** Read a whole new block **/
	result = FFGET_getnewblock(f);

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x22f0
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x995e
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x23a0
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %r8d
movq %rax, %r9
leaq 0x1283d(%rip), %rdi     # 0x1c17f
leaq 0x127f5(%rip), %rsi     # 0x1c13e
movl $0x128, %edx            # imm = 0x128
movb $0x0, %al
callq 0x117c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9970
movq -0x10(%rbp), %rdi
callq 0x94f0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ffget.c
// Function: FFGET_fgetc
char FFGET_fgetc( FFGET_FILE *f )
#endif
{
	int c;

	if (f->ungetcset)
	{
		f->ungetcset = 0;
		return f->c;
	}

	if ((!f->startpoint)||(f->startpoint > f->endpoint))
	{
		FFGET_getnewblock(f);
	}

	if (f->FFEOF == 0)
	{
		c = *f->startpoint;
		f->startpoint++;
	}
	else
	{
		c = EOF;
	}

	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2050(%rax)
je 0x9a26
movq -0x10(%rbp), %rax
movl $0x0, 0x2050(%rax)
movq -0x10(%rbp), %rax
movb 0x2038(%rax), %al
movb %al, -0x1(%rbp)
jmp 0x9a98
movq -0x10(%rbp), %rax
cmpq $0x0, 0x2010(%rax)
je 0x9a4c
movq -0x10(%rbp), %rax
movq 0x2010(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x2018(%rcx), %rax
jbe 0x9a55
movq -0x10(%rbp), %rdi
callq 0x94f0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2034(%rax)
jne 0x9a8b
movq -0x10(%rbp), %rax
movq 0x2010(%rax), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x2010(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x2010(%rax)
jmp 0x9a92
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ffget.c
// Function: FFGET_raw
int FFGET_raw( FFGET_FILE *f, unsigned char *buffer, int max )
{

	unsigned char c;					// read buffer

	int bytestogo = 0;
	int count = 0;						// How many bytes read

	// Special situation here, if we have a return from MIME_headers which indicates
	// that we have data in a MIMEH_pushback, then we need to process that first, before we
	// go back into the data file.


	if ((!f->startpoint)||(f->startpoint > f->endpoint))
	{
		bytestogo = FFGET_getnewblock(f);
	}
	else
	{
		bytestogo = f->endpoint -f->startpoint +1;
	}

	// Whilst we've got less bytes than the maximum availabe
	// for the buffer, we keep on reading
	//

	while (count < max)
	{

		if (!bytestogo)
		{
			bytestogo = FFGET_getnewblock(f);
		}

		if (!f->FFEOF)
		{
			c = *f->startpoint;
			f->startpoint++;
			*buffer = c;

			buffer++;

			count++;

			bytestogo--;

			// If we get a line delimeter, check to see that the next char (which is now
			// pointed to at f->startpoint isn't a delimeter as well which perhaps we should
			// be including in our line were' going to return
			//
			// 25/05/02 - Silly mistake, I had (!\n || !\r) when it should be && (ie, if the next
			// char is NEITHER of the \n or \r chars, then break.
			//

			if ((c == '\n')||(c == '\r'))
			{
				if (  (*(f->startpoint) != '\n') && (*(f->startpoint) != '\r') )
					break;
			}
		}
		else break;
	}

	*buffer = '\0';

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x2010(%rax)
je 0xa167
movq -0x8(%rbp), %rax
movq 0x2010(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x2018(%rcx), %rax
jbe 0xa175
movq -0x8(%rbp), %rdi
callq 0x94f0
movl %eax, -0x1c(%rbp)
jmp 0xa195
movq -0x8(%rbp), %rax
movq 0x2018(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x2010(%rcx), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
jmp 0xa197
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xa258
cmpl $0x0, -0x1c(%rbp)
jne 0xa1b5
movq -0x8(%rbp), %rdi
callq 0x94f0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2034(%rax)
jne 0xa251
movq -0x8(%rbp), %rax
movq 0x2010(%rax), %rax
movb (%rax), %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movq 0x2010(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x2010(%rax)
movb -0x15(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movzbl -0x15(%rbp), %eax
cmpl $0xa, %eax
je 0xa225
movzbl -0x15(%rbp), %eax
cmpl $0xd, %eax
jne 0xa24f
movq -0x8(%rbp), %rax
movq 0x2010(%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0xa24d
movq -0x8(%rbp), %rax
movq 0x2010(%rax), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
je 0xa24d
jmp 0xa258
jmp 0xa24f
jmp 0xa253
jmp 0xa258
jmp 0xa197
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_init
int MIMEH_init( void )
{
    glb.doubleCR = 0;
    glb.headerline = NULL;
    glb.headerline_original = NULL;
    glb.header_file = NULL;
    glb.original_header_file = NULL;
    glb.original_header_save_to_file = 0;

    glb.save_headers = 0;
    glb.save_headers_original = 0;
    glb.test_mailbox = 0;
    glb.debug = 0;
    glb.webform = 0;
    glb.doubleCR_count = 0;
    glb.doubleCR_save = 1;
    glb.header_fix = 1;
    glb.verbose = 0;
    glb.verbose_contenttype = 0;
    glb.output_dir[0]='\0';
    glb.doubleCRname[0]='\0';
    glb.appledouble_filename[0]='\0';
    glb.header_longsearch=0;
    glb.longsearch_limit=1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x20cc2(%rip)     # 0x2af70
movq $0x0, 0x284a7(%rip) # 0x32760
movq $0x0, 0x284a4(%rip) # 0x32768
movq $0x0, 0x2acc9(%rip) # 0x34f98
movq $0x0, 0x2acc6(%rip) # 0x34fa0
movl $0x0, 0x2acc4(%rip)     # 0x34fa8
movl $0x0, 0x28482(%rip)     # 0x32770
movl $0x0, 0x2847c(%rip)     # 0x32774
movl $0x0, 0x28476(%rip)     # 0x32778
movl $0x0, 0x28470(%rip)     # 0x3277c
movl $0x0, 0x2846a(%rip)     # 0x32780
movl $0x0, 0x28464(%rip)     # 0x32784
movl $0x1, 0x20c4a(%rip)     # 0x2af74
movl $0x1, 0x28454(%rip)     # 0x32788
movl $0x0, 0x2844e(%rip)     # 0x3278c
movl $0x0, 0x28448(%rip)     # 0x32790
movb $0x0, 0x2844d(%rip)     # 0x3279c
movb $0x0, 0x20c22(%rip)     # 0x2af78
movb $0x0, 0x23412(%rip)     # 0x2d76f
movl $0x0, 0x2842d(%rip)     # 0x32794
movl $0x1, 0x28427(%rip)     # 0x32798
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_set_headers_original_save_to_file
int MIMEH_set_headers_original_save_to_file( FILE *f )
{
    if (f == NULL) glb.original_header_save_to_file = 0;
    else glb.original_header_save_to_file = 1;
    glb.original_header_file = f;

    return glb.original_header_save_to_file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa55b
movl $0x0, 0x2aa4f(%rip)     # 0x34fa8
jmp 0xa565
movl $0x1, 0x2aa43(%rip)     # 0x34fa8
movq -0x8(%rbp), %rax
movq %rax, 0x2aa30(%rip)     # 0x34fa0
movl 0x2aa32(%rip), %eax     # 0x34fa8
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_set_defect
int MIMEH_set_defect( struct MIMEH_header_info *hinfo, int defect )
{
    if ((defect >= 0)&&(defect < _MIMEH_DEFECT_ARRAY_SIZE))
    {
        hinfo->defects[defect]++;
        hinfo->header_defect_count++;
        DMIMEH LOGGER_log("%s:%d:MIMEH_set_defect:DEBUG: Setting defect index '%d' to '%d'",FL, defect, hinfo->defects[defect]);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xa68f
cmpl $0x64, -0xc(%rbp)
jge 0xa68f
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x18b98(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x18b98(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x18d28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18d28(%rax)
cmpl $0x1, 0x2811e(%rip)     # 0x3277c
jl 0xa68d
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
movl 0x18b98(%rax,%rdx,4), %r8d
leaq 0x11db4(%rip), %rdi     # 0x1c42e
leaq 0x11ded(%rip), %rsi     # 0x1c46e
movl $0x25f, %edx            # imm = 0x25F
movb $0x0, %al
callq 0x117c0
jmp 0xa68f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_is_binary
int MIMEH_is_binary( char *fname )
{
    char buffer[1024];
    int read_count;
    FILE *f;

    f = fopen(fname,"r");
    if (!f) return 1;
    read_count = fread(buffer, 1, 1024, f);
    fclose(f);

    while (read_count)
    {
        read_count--;
        if (buffer[read_count] == 0) return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x12f9a(%rip), %rsi     # 0x1d694
callq 0x2330
movq %rax, -0x420(%rbp)
cmpq $0x0, -0x420(%rbp)
jne 0xa719
movl $0x1, -0x4(%rbp)
jmp 0xa786
leaq -0x410(%rbp), %rdi
movq -0x420(%rbp), %rcx
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x20b0
movl %eax, -0x414(%rbp)
movq -0x420(%rbp), %rdi
callq 0x20e0
cmpl $0x0, -0x414(%rbp)
je 0xa77f
movl -0x414(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x414(%rbp)
movslq -0x414(%rbp), %rax
movsbl -0x410(%rbp,%rax), %eax
cmpl $0x0, %eax
jne 0xa77d
movl $0x1, -0x4(%rbp)
jmp 0xa786
jmp 0xa748
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_save_doubleCR
int MIMEH_save_doubleCR( FFGET_FILE *f )
{
    //char c;
    int c;
    FILE *fo;
    struct stat st;

    // Determine a file name we can use.
    do {
        glb.doubleCR_count++;
        snprintf(glb.doubleCRname,_MIMEH_STRLEN_MAX,"%s/doubleCR.%d",glb.output_dir,glb.doubleCR_count);
    }
    while (stat(glb.doubleCRname, &st) == 0);


    fo = fopen(glb.doubleCRname,"w");
    if (!fo)
    {
        LOGGER_log("%s:%d:MIMEH_save_doubleCR:ERROR: unable to open '%s' to write (%s)", FL,glb.doubleCRname,strerror(errno));
        return -1;
    }

    if (MIMEH_DNORMAL) LOGGER_log("%s:%d:MIME_save_doubleCR:DEBUG: Saving DoubleCR header: %s\n", FL,glb.doubleCRname);
    while (1)
    {
        c = FFGET_fgetc(f);
        fprintf(fo,"%c",c);
        if ((c == EOF)||(c == '\n'))
        {
            break;
        }
    }
    fclose(fo);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movl 0x27dbf(%rip), %eax     # 0x32784
addl $0x1, %eax
movl %eax, 0x27db6(%rip)     # 0x32784
movl 0x27daf(%rip), %r8d     # 0x32784
leaq 0x20594(%rip), %rcx     # 0x2af70
movq %rcx, %rdi
addq $0x8, %rdi
movl $0x27f6, %esi           # imm = 0x27F6
leaq 0x11b7d(%rip), %rdx     # 0x1c56c
addq $0x782c, %rcx           # imm = 0x782C
movb $0x0, %al
callq 0x2130
leaq 0x2056c(%rip), %rdi     # 0x2af70
addq $0x8, %rdi
leaq -0xb0(%rbp), %rsi
callq 0x2230
cmpl $0x0, %eax
je 0xa9bf
leaq 0x20550(%rip), %rdi     # 0x2af70
addq $0x8, %rdi
leaq 0xf3a0(%rip), %rsi      # 0x19dcb
callq 0x2330
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xaa78
callq 0x2050
movl (%rax), %edi
callq 0x23a0
movq %rax, %r8
leaq 0x11b2a(%rip), %rdi     # 0x1c57b
leaq 0x11a16(%rip), %rsi     # 0x1c46e
movl $0x2fb, %edx            # imm = 0x2FB
leaq 0x2050c(%rip), %rcx     # 0x2af70
addq $0x8, %rcx
movb $0x0, %al
callq 0x117c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xaaec
cmpl $0x1, 0x27cfd(%rip)     # 0x3277c
jl 0xaaa6
leaq 0x11b36(%rip), %rdi     # 0x1c5be
leaq 0x119df(%rip), %rsi     # 0x1c46e
movl $0x2ff, %edx            # imm = 0x2FF
leaq 0x204d5(%rip), %rcx     # 0x2af70
addq $0x8, %rcx
movb $0x0, %al
callq 0x117c0
jmp 0xaaa8
movq -0x10(%rbp), %rdi
callq 0x99f0
movsbl %al, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x12192(%rip), %rsi     # 0x1cc57
movb $0x0, %al
callq 0x2200
cmpl $-0x1, -0x14(%rbp)
je 0xaad8
cmpl $0xa, -0x14(%rbp)
jne 0xaada
jmp 0xaadc
jmp 0xaaa8
movq -0x20(%rbp), %rdi
callq 0x20e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_strcasestr
char *MIMEH_strcasestr(char *haystack, char *needle)
{
    char *hs, *ne;
    char *result = NULL;

    hs = strdup(haystack);
    PLD_strlower(hs);
    ne = strdup(needle);
    PLD_strlower(ne);

    if (hs && ne) {
        result = strstr(hs, ne);
        result = result -hs +haystack;
    }

    if (hs) free(hs);
    if (ne) free(ne);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2390
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x105f0
movq -0x10(%rbp), %rdi
callq 0x2390
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x105f0
cmpq $0x0, -0x18(%rbp)
je 0xaee6
cmpq $0x0, -0x20(%rbp)
je 0xaee6
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x23b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
addq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xaef6
movq -0x18(%rbp), %rdi
callq 0x2030
cmpq $0x0, -0x20(%rbp)
je 0xaf06
movq -0x20(%rbp), %rdi
callq 0x2030
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq