LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_check_ct
int MIMEH_check_ct(char *q)
{
    char *p=q;
    p++;
    if(*p!='\0' && MIMEH_strcasestr(p,"Content-Type:")==p)return 1;
    p++;
    if(*p!='\0' && MIMEH_strcasestr(p,"Content-Type:")==p)return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xaf5b
movq -0x18(%rbp), %rdi
leaq 0x117c6(%rip), %rsi     # 0x1c70d
callq 0xae70
cmpq -0x18(%rbp), %rax
jne 0xaf5b
movl $0x1, -0x4(%rbp)
jmp 0xaf99
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xaf92
movq -0x18(%rbp), %rdi
leaq 0x1178f(%rip), %rsi     # 0x1c70d
callq 0xae70
cmpq -0x18(%rbp), %rax
jne 0xaf92
movl $0x1, -0x4(%rbp)
jmp 0xaf99
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_display_info
int MIMEH_display_info( struct MIMEH_header_info *hinfo )
{
    if (hinfo)
    {
        LOGGER_log("%s:%d:MIMEH_display_info:\
                Content Type = %d\n\
                Boundary = %s\n\
                Filename = %s\n\
                name = %s\n\
                Encoding = %d\n\
                Disposit = %d\n\
                "\
                ,FL\
                ,hinfo->content_type\
                ,hinfo->boundary\
                ,hinfo->filename\
                ,hinfo->name\
                ,hinfo->content_transfer_encoding\
                ,hinfo->content_disposition);
        fflush(stdout);
    }
    return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xbda9
movq -0x8(%rbp), %rax
movl 0x27f8(%rax), %ecx
movq -0x8(%rbp), %r8
addq $0x31fe, %r8            # imm = 0x31FE
movq -0x8(%rbp), %r9
addq $0x5efd, %r9            # imm = 0x5EFD
movq -0x8(%rbp), %r11
addq $0x6efe, %r11           # imm = 0x6EFE
movq -0x8(%rbp), %rax
movl 0x166f8(%rax), %r10d
movq -0x8(%rbp), %rax
movl 0x17100(%rax), %eax
leaq 0x11164(%rip), %rdi     # 0x1cede
leaq 0x106ed(%rip), %rsi     # 0x1c46e
movl $0x528, %edx            # imm = 0x528
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0x117c0
movq 0x1a22f(%rip), %rax     # 0x25fd0
movq (%rax), %rdi
callq 0x22b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_decode_multivalue_language_string
int MIMEH_decode_multivalue_language_string( char *input )
{
    int sq_count = 0;
    int language_set = 0;
    char *q = input;

    DMIMEH LOGGER_log("%s:%d:MIMEH_decode_multivalue_language_string:DEBUG: Decoding '%s'",FL,input);
    // Count the single-quotes
    while ((*q != '\0')&&(sq_count != 2)) if (*q++ == '\'') sq_count++;
    if (sq_count < 2)
    {
        //      LOGGER_log("%s:%d:MIMEH_decode_multivalue_language_string:WARNING: Insufficient single quotes for valid language-charset string",FL);
        q = input;
    } else {
        language_set = 1;
    }

    // q will be pointing at the 2nd single-quote, which is the end of
    // the language encoding set, so we just jump over that and start
    // reading off the data and decoding it.
    MDECODE_decode_multipart( q );

    // If the language was set, we need to move down our decoded data to the
    //      start of the input buffer
    if (language_set == 1)
    {
        while (*q != '\0') { *input = *q; input++; q++; }
        *input = '\0';
    }

    DMIMEH LOGGER_log("%s:%d:MIMEH_decode_multivalue_language_string:DEBUG: Output = '%s'",FL,q);


    return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, 0x26993(%rip)     # 0x3277c
jl 0xbe09
movq -0x8(%rbp), %rcx
leaq 0x111c6(%rip), %rdi     # 0x1cfbc
leaq 0x10671(%rip), %rsi     # 0x1c46e
movl $0x54a, %edx            # imm = 0x54A
movb $0x0, %al
callq 0x117c0
jmp 0xbe0b
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0xbe26
cmpl $0x2, -0xc(%rbp)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xbe2f
jmp 0xbe51
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0xbe4f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbe0b
cmpl $0x2, -0xc(%rbp)
jge 0xbe61
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xbe68
movl $0x1, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11fe0
cmpl $0x1, -0x10(%rbp)
jne 0xbeb2
jmp 0xbe79
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xbeab
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xbe79
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x1, 0x268c3(%rip)     # 0x3277c
jl 0xbed9
movq -0x18(%rbp), %rcx
leaq 0x11139(%rip), %rdi     # 0x1cfff
leaq 0x105a1(%rip), %rsi     # 0x1c46e
movl $0x562, %edx            # imm = 0x562
movb $0x0, %al
callq 0x117c0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_is_valid_header_prefix
int MIMEH_is_valid_header_prefix( char *data, char *prefix_name )
{
    int plen = strlen(prefix_name);

    /** If our string doesn't start with content-type, then exit **/
    if (strncasecmp(data, prefix_name, plen)!=0)
    {
        return 0;
    } else {
        char end_char;

        /** Test to see that the terminating char after the content-type
         ** string is suitable to indicating that the content-type is
         ** infact a header name
         **/
        end_char = *(data +plen);
        switch (end_char){
            case ':':
            case ' ':
            case '\t':
            case '\0':
                /** Valid terminating characters found **/
                break;
            default:
                /** Otherwise, return 0 **/
                return 0;
        } /** switch end_char **/
    } /** if-else **/

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2100
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x22a0
cmpl $0x0, %eax
je 0xcaab
movl $0x0, -0x4(%rbp)
jmp 0xcaf8
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0xcae4
jmp 0xcac6
movl -0x24(%rbp), %eax
subl $0x9, %eax
je 0xcae4
jmp 0xcad0
movl -0x24(%rbp), %eax
subl $0x20, %eax
je 0xcae4
jmp 0xcada
movl -0x24(%rbp), %eax
subl $0x3a, %eax
jne 0xcae6
jmp 0xcae4
jmp 0xcaef
movl $0x0, -0x4(%rbp)
jmp 0xcaf8
jmp 0xcaf1
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_parse_contenttype_linear_EXPERIMENT
int MIMEH_parse_contenttype_linear_EXPERIMENT( char *header_name, char *header_value, struct MIMEH_header_info *hinfo )
{
    char *chv = header_value;
    char *chn = header_name;
    int boundary_found = 0;
    //  int name_found = 0;
    //  int filename_found = 0;

    /** Absorb whitespace **/
    while (isspace(*chn)) chn++;

    /** Test if the content-type string is valid **/
    if (MIMEH_is_valid_header_prefix(chn, "content-type")==0) return 0;

    /** Now, let's try parse our content-type parameter/value string **/
    while (*chv)
    {
        while (isspace(*chv)) chv++;
        if ((boundary_found==0)&&(MIMEH_is_valid_header_prefix(chv,"boundary")==1))
        {
        }

        //      if (strncasecmp(chv, "boundary"

    }


    return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
callq 0x23c0
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xcb69
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xcb3b
movq -0x30(%rbp), %rdi
leaq 0x10a19(%rip), %rsi     # 0x1d58d
callq 0xca70
cmpl $0x0, %eax
jne 0xcb87
movl $0x0, -0x4(%rbp)
jmp 0xcbe8
jmp 0xcb89
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0xcbe1
jmp 0xcb94
callq 0x23c0
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xcbc2
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xcb94
cmpl $0x0, -0x34(%rbp)
jne 0xcbdf
movq -0x28(%rbp), %rdi
leaq 0xd283(%rip), %rsi      # 0x19e56
callq 0xca70
cmpl $0x1, %eax
jne 0xcbdf
jmp 0xcbdf
jmp 0xcb89
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_parse_subject
int MIMEH_parse_subject( char *header_name, char *header_value, struct MIMEH_header_info *hinfo )
{
    int result = 0;
    result = MIMEH_parse_generic( header_name, header_value, hinfo, "subject", hinfo->subject, sizeof(hinfo->subject)  );
    snprintf(glb.subject, sizeof(glb.subject),"%s", hinfo->subject);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %r8
addq $0x59fc, %r8            # imm = 0x59FC
leaq 0xfbc3(%rip), %rcx      # 0x1dd3c
movl $0x501, %r9d            # imm = 0x501
callq 0xdfb0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rcx
addq $0x59fc, %rcx           # imm = 0x59FC
leaq 0x1cdd7(%rip), %rdi     # 0x2af70
addq $0x4ff6, %rdi           # imm = 0x4FF6
movl $0x27f7, %esi           # imm = 0x27F7
leaq 0x10dfe(%rip), %rdx     # 0x1efaa
movb $0x0, %al
callq 0x2130
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_parse_charset
int MIMEH_parse_charset( char *header_name, char *header_value, struct MIMEH_header_info *hinfo )
{
    int result = 0;

    result = MIMEH_parse_generic( header_name, header_value, hinfo, "charset", hinfo->charset, sizeof(hinfo->charset) );
    if (MIMEH_DNORMAL) LOGGER_log("%s:%d:MIMEH_parse_charset:DEBUG: Charset value = '%s'", FL, hinfo->charset);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %r8
addq $0x17b05, %r8           # imm = 0x17B05
leaq 0xf9dc(%rip), %rcx      # 0x1dd65
movl $0x81, %r9d
callq 0xdfb0
movl %eax, -0x1c(%rbp)
cmpl $0x1, 0x243de(%rip)     # 0x3277c
jl 0xe3c5
movq -0x18(%rbp), %rcx
addq $0x17b05, %rcx          # imm = 0x17B05
leaq 0xf9bb(%rip), %rdi      # 0x1dd6d
leaq 0xe0b5(%rip), %rsi      # 0x1c46e
movl $0xaa3, %edx            # imm = 0xAA3
movb $0x0, %al
callq 0x117c0
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_headers_clearcount
int MIMEH_headers_clearcount( struct MIMEH_header_info *hinfo ) {

    hinfo->crlf_count = 0;
    hinfo->lf_count = 0;
    hinfo->crcr_count = 0;
    return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x18d3c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18d44(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18d40(%rax)
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_headers_cleanup
int MIMEH_headers_cleanup( void )
{
    if (glb.headerline != NULL)
    {
        free(glb.headerline);
        glb.headerline = NULL;
    }

    if (glb.headerline_original != NULL)
    {
        free(glb.headerline_original);
        glb.headerline_original = NULL;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x23b94(%rip)     # 0x32760
je 0xebe5
movq 0x23b8b(%rip), %rdi     # 0x32760
callq 0x2030
movq $0x0, 0x23b7b(%rip) # 0x32760
cmpq $0x0, 0x23b7b(%rip)     # 0x32768
je 0xec06
movq 0x23b72(%rip), %rdi     # 0x32768
callq 0x2030
movq $0x0, 0x23b62(%rip) # 0x32768
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/MIME_headers.c
// Function: MIMEH_parse_headers
int MIMEH_parse_headers( FFGET_FILE *f, struct MIMEH_header_info *hinfo )
{
    int result = 0;
    DMIMEH LOGGER_log("%s:%d:MIMEH_parse_headers:DEBUG: Start [F=%p, hinfo=%p]\n", FL, f, hinfo);

    /** 20041216-1100:PLD: Set the header sanity to zero **/
    if ( result == 0 ) hinfo->sanity = 0;

    /** Proceed to read, process and finish headers **/
    DMIMEH LOGGER_log("%s:%d:MIMEH_parse_headers:DEBUG: Getting headers",FL);
    if ( result == 0 ) result = MIMEH_headers_get( hinfo, f );
    DMIMEH LOGGER_log("%s:%d:MIMEH_parse_headers:DEBUG: Processing headers",FL);
    if ( result == 0 ) result = MIMEH_headers_process( hinfo, glb.headerline );
    DMIMEH LOGGER_log("%s:%d:MIMEH_parse_headers:DEBUG: cleanup of headers",FL);
    if ( result == 0 ) result = MIMEH_headers_cleanup();
    if (MIMEH_DNORMAL) LOGGER_log("%s:%d:MIMEH_parse_headers:DEBUG: END [F=%p, hinfo=%p, sanity=%d]\n", FL, f, hinfo, hinfo->sanity);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x1, 0x23b4e(%rip)     # 0x3277c
jl 0xec52
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
leaq 0xf549(%rip), %rdi      # 0x1e188
leaq 0xd828(%rip), %rsi      # 0x1c46e
movl $0xc18, %edx            # imm = 0xC18
movb $0x0, %al
callq 0x117c0
cmpl $0x0, -0x14(%rbp)
jne 0xec66
movq -0x10(%rbp), %rax
movl $0x0, 0x18d30(%rax)
cmpl $0x1, 0x23b0f(%rip)     # 0x3277c
jl 0xec89
leaq 0xf54b(%rip), %rdi      # 0x1e1c1
leaq 0xd7f1(%rip), %rsi      # 0x1c46e
movl $0xc1e, %edx            # imm = 0xC1E
movb $0x0, %al
callq 0x117c0
cmpl $0x0, -0x14(%rbp)
jne 0xec9f
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xe910
movl %eax, -0x14(%rbp)
cmpl $0x1, 0x23ad6(%rip)     # 0x3277c
jl 0xecc2
leaq 0xf543(%rip), %rdi      # 0x1e1f2
leaq 0xd7b8(%rip), %rsi      # 0x1c46e
movl $0xc20, %edx            # imm = 0xC20
movb $0x0, %al
callq 0x117c0
cmpl $0x0, -0x14(%rbp)
jne 0xecdb
movq -0x10(%rbp), %rdi
movq 0x23a8d(%rip), %rsi     # 0x32760
callq 0xe3d0
movl %eax, -0x14(%rbp)
cmpl $0x1, 0x23a9a(%rip)     # 0x3277c
jl 0xecfe
leaq 0xf53b(%rip), %rdi      # 0x1e226
leaq 0xd77c(%rip), %rsi      # 0x1c46e
movl $0xc22, %edx            # imm = 0xC22
movb $0x0, %al
callq 0x117c0
cmpl $0x0, -0x14(%rbp)
jne 0xed0c
callq 0xebc0
movl %eax, -0x14(%rbp)
cmpl $0x1, 0x23a69(%rip)     # 0x3277c
jl 0xed42
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x10(%rbp), %rax
movl 0x18d30(%rax), %r9d
leaq 0xf52b(%rip), %rdi      # 0x1e25a
leaq 0xd738(%rip), %rsi      # 0x1c46e
movl $0xc24, %edx            # imm = 0xC24
movb $0x0, %al
callq 0x117c0
movl -0x14(%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_dump_defects
int MIMEH_dump_defects( struct MIMEH_header_info *hinfo )
{
    int i;

    MIMEH_defect_description_array[MIMEH_DEFECT_MISSING_SEPARATORS] = strdup("Missing separators");
    MIMEH_defect_description_array[MIMEH_DEFECT_MULTIPLE_FIELD_OCCURANCE] = strdup("Multiple field occurance");
    MIMEH_defect_description_array[MIMEH_DEFECT_UNBALANCED_BOUNDARY_QUOTE] = strdup("Unbalanced boundary quote");
    MIMEH_defect_description_array[MIMEH_DEFECT_MULTIPLE_BOUNDARIES] = strdup("Multiple boundries");
    MIMEH_defect_description_array[MIMEH_DEFECT_MULTIPLE_COLON_SEPARATORS] = strdup("Multiple colon separators");
    MIMEH_defect_description_array[MIMEH_DEFECT_MULTIPLE_EQUALS_SEPARATORS] = strdup("Multiple equals separators");
    MIMEH_defect_description_array[MIMEH_DEFECT_UNBALANCED_QUOTES] = strdup("Unbalanced quotes");
    MIMEH_defect_description_array[MIMEH_DEFECT_MULTIPLE_QUOTES] = strdup("Multiple quotes");
    MIMEH_defect_description_array[MIMEH_DEFECT_MULTIPLE_NAMES] = strdup("Multiple names");
    MIMEH_defect_description_array[MIMEH_DEFECT_MULTIPLE_FILENAMES] = strdup("Multiple filenames");

    for (i = 0; i < _MIMEH_DEFECT_ARRAY_SIZE; i++)
    {
        if (hinfo->defects[i] > 0)
        {
            LOGGER_log("Header Defect: %s: %d",MIMEH_defect_description_array[i],hinfo->defects[i]);
        }

    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xf539(%rip), %rdi      # 0x1e29c
callq 0x2390
movq %rax, 0x26281(%rip)     # 0x34ff0
leaq 0xf539(%rip), %rdi      # 0x1e2af
callq 0x2390
movq %rax, 0x26266(%rip)     # 0x34fe8
leaq 0xf53f(%rip), %rdi      # 0x1e2c8
callq 0x2390
movq %rax, 0x2624b(%rip)     # 0x34fe0
leaq 0xf546(%rip), %rdi      # 0x1e2e2
callq 0x2390
movq %rax, 0x26230(%rip)     # 0x34fd8
leaq 0xf546(%rip), %rdi      # 0x1e2f5
callq 0x2390
movq %rax, 0x26215(%rip)     # 0x34fd0
leaq 0xf54d(%rip), %rdi      # 0x1e30f
callq 0x2390
movq %rax, 0x261fa(%rip)     # 0x34fc8
leaq 0xf555(%rip), %rdi      # 0x1e32a
callq 0x2390
movq %rax, 0x261df(%rip)     # 0x34fc0
leaq 0xf554(%rip), %rdi      # 0x1e33c
callq 0x2390
movq %rax, 0x261c4(%rip)     # 0x34fb8
leaq 0xf551(%rip), %rdi      # 0x1e34c
callq 0x2390
movq %rax, 0x261f1(%rip)     # 0x34ff8
leaq 0xf54d(%rip), %rdi      # 0x1e35b
callq 0x2390
movq %rax, 0x261e6(%rip)     # 0x35000
movl $0x0, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jge 0xee72
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, 0x18b98(%rax,%rcx,4)
jle 0xee65
movslq -0xc(%rbp), %rcx
leaq 0x2616c(%rip), %rax     # 0x34fb0
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0x18b98(%rax,%rcx,4), %edx
leaq 0xf510(%rip), %rdi      # 0x1e36e
movb $0x0, %al
callq 0x117c0
jmp 0xee67
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xee21
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_read_primary_headers
int MIMEH_read_primary_headers( char *fname, struct MIMEH_header_info *hinfo )
{
    FFGET_FILE F;
    FILE *f;

    f = fopen(fname,"r");
    if (!f) {
        LOGGER_log("%s:%d:MIMEH_read_primary_headers:ERROR: Cannot open mailpack '%s' (%s)", FL, fname, strerror(errno));
        return 0;
    }
    FFGET_setstream(&F,f);

    MIMEH_parse_headers(&F, hinfo);
    fclose(f);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20a0, %rsp           # imm = 0x20A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xe7d6(%rip), %rsi      # 0x1d694
callq 0x2330
movq %rax, -0x2090(%rbp)
cmpq $0x0, -0x2090(%rbp)
jne 0xef18
movq -0x10(%rbp), %rax
movq %rax, -0x2098(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x23a0
movq -0x2098(%rbp), %rcx
movq %rax, %r8
leaq 0xf488(%rip), %rdi      # 0x1e384
leaq 0xd56b(%rip), %rsi      # 0x1c46e
movl $0xc82, %edx            # imm = 0xC82
movb $0x0, %al
callq 0x117c0
movl $0x0, -0x4(%rbp)
jmp 0xef4e
movq -0x2090(%rbp), %rsi
leaq -0x2088(%rbp), %rdi
callq 0x9760
movq -0x18(%rbp), %rsi
leaq -0x2088(%rbp), %rdi
callq 0xec10
movq -0x2090(%rbp), %rdi
callq 0x20e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20a0, %rsp           # imm = 0x20A0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/tnef/tnef.c
// Function: TNEF_init
int TNEF_init( void )
{
	TNEF_glb.file_num = 0;
	TNEF_glb.verbose = 0;
	TNEF_glb.verbosity_contenttype = 0;
	TNEF_glb.debug = 0;
	TNEF_glb.savedata = 1;
	TNEF_glb.TNEF_Verbose = 0;
	TNEF_glb.filename_decoded_report = NULL;
	TNEF_glb.path[0] = '\0';

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x26362(%rip)     # 0x352d0
movl $0x0, 0x2635c(%rip)     # 0x352d4
movl $0x0, 0x26356(%rip)     # 0x352d8
movl $0x0, 0x26350(%rip)     # 0x352dc
movl $0x1, 0x26752(%rip)     # 0x356e8
movl $0x0, 0x26744(%rip)     # 0x356e4
movq $0x0, 0x26755(%rip) # 0x35700
movb $0x0, 0x2632e(%rip)     # 0x352e0
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/tnef/tnef.c
// Function: read_32
int read_32( uint32 *value, uint8 *tsp)
{
	uint8 a,b,c,d;

	if ((tsp +4) > TNEF_glb.tnef_limit)
	{
		if ((TNEF_VERBOSE)||(TNEF_DEBUG)) LOGGER_log("%s:%d:TNEF_read_32:ERROR: Attempting to read beyond end of memory block",FL);
		return -1;
	}

	a = *tsp;
	b = *(tsp+1);
	c = *(tsp+2);
	d = *(tsp+3);

	*value =  long_little_endian(a<<24 | b<<16 | c<<8 | d);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
cmpq 0x26629(%rip), %rax     # 0x356f8
jbe 0xf109
cmpl $0x0, 0x261fc(%rip)     # 0x352d4
jg 0xf0e3
cmpl $0x0, 0x261fb(%rip)     # 0x352dc
jle 0xf0fd
leaq 0xf306(%rip), %rdi      # 0x1e3f0
leaq 0xf347(%rip), %rsi      # 0x1e438
movl $0xfb, %edx
movb $0x0, %al
callq 0x117c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf1fd
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x1b(%rbp)
movq -0x18(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x1c(%rbp)
movzbl -0x19(%rbp), %eax
shll $0x18, %eax
movzbl -0x1a(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movzbl -0x1b(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzbl -0x1c(%rbp), %ecx
orl %ecx, %eax
movl %eax, %eax
andq $0xff00, %rax           # imm = 0xFF00
shlq $0x8, %rax
movzbl -0x19(%rbp), %ecx
shll $0x18, %ecx
movzbl -0x1a(%rbp), %edx
shll $0x10, %edx
orl %edx, %ecx
movzbl -0x1b(%rbp), %edx
shll $0x8, %edx
orl %edx, %ecx
movzbl -0x1c(%rbp), %edx
orl %edx, %ecx
movl %ecx, %ecx
andq $0xff, %rcx
shlq $0x18, %rcx
orq %rcx, %rax
movzbl -0x19(%rbp), %ecx
shll $0x18, %ecx
movzbl -0x1a(%rbp), %edx
shll $0x10, %edx
orl %edx, %ecx
movzbl -0x1b(%rbp), %edx
shll $0x8, %edx
orl %edx, %ecx
movzbl -0x1c(%rbp), %edx
orl %edx, %ecx
movl %ecx, %ecx
andq $0xff0000, %rcx         # imm = 0xFF0000
shrq $0x8, %rcx
orq %rcx, %rax
movzbl -0x19(%rbp), %ecx
shll $0x18, %ecx
movzbl -0x1a(%rbp), %edx
shll $0x10, %edx
orl %edx, %ecx
movzbl -0x1b(%rbp), %edx
shll $0x8, %edx
orl %edx, %ecx
movzbl -0x1c(%rbp), %edx
orl %edx, %ecx
movl %ecx, %ecx
movabsq $0xff000000, %rdx       # imm = 0xFF000000
andq %rdx, %rcx
shrq $0x18, %rcx
orq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/tnef/tnef.c
// Function: read_16
int read_16( uint16 *value, uint8 *tsp)
{
	uint8 a,b;

	if (
			((tsp +2) > TNEF_glb.tnef_limit)
//PLD-20070707-17H20, how do we even compare tsp to a negative!?		||(tsp == -1)
			)
	{
		if ((TNEF_VERBOSE)||(TNEF_DEBUG)) LOGGER_log("%s:%d:TNEF_read_16:ERROR: Attempting to read past end\n",FL);
		return -1;
	}

	//	if (TNEF_DEBUG) fprintf(stderr,"Read_16: Offset read %d\n", tsp -tnef_home);

	a = *tsp;
	b = *(tsp + 1);

	*value = little_endian(a<<8 | b);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
cmpq 0x264c9(%rip), %rax     # 0x356f8
jbe 0xf266
cmpl $0x0, 0x2609c(%rip)     # 0x352d4
jg 0xf243
cmpl $0x0, 0x2609b(%rip)     # 0x352dc
jle 0xf25d
leaq 0xf1f5(%rip), %rdi      # 0x1e43f
leaq 0xf1e7(%rip), %rsi      # 0x1e438
movl $0x119, %edx            # imm = 0x119
movb $0x0, %al
callq 0x117c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf2bd
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x1a(%rbp)
movzbl -0x19(%rbp), %eax
shll $0x8, %eax
movzbl -0x1a(%rbp), %ecx
orl %ecx, %eax
movzwl %ax, %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movzbl -0x19(%rbp), %ecx
shll $0x8, %ecx
movzbl -0x1a(%rbp), %edx
orl %edx, %ecx
movzwl %cx, %ecx
andl $0xff, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/tnef/tnef.c
// Function: save_attach_data
int save_attach_data(char *title, uint8 *tsp, uint32 size)
{
	FILE *out;
	char filename[1024];
	size_t bc;

	snprintf(filename, sizeof(filename),"%s/%s", TNEF_glb.path, title );

	out = fopen(filename, "w");
	if (!out)
	{
		LOGGER_log("%s:%d:TNEF_save_attach_data:ERROR: Failed opening file %s for writing (%s)\n", FL, filename, strerror(errno));
		return -1;
	}

	bc = fwrite(tsp, sizeof(uint8), size, out);
	fclose(out);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq -0x430(%rbp), %rdi
movq -0x10(%rbp), %r8
movl $0x400, %esi            # imm = 0x400
leaq 0xa1bf(%rip), %rdx      # 0x194fc
leaq 0x25f8c(%rip), %rcx     # 0x352d0
addq $0x10, %rcx
movb $0x0, %al
callq 0x2130
leaq -0x430(%rbp), %rdi
leaq 0xaa6e(%rip), %rsi      # 0x19dcb
callq 0x2330
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf3b4
leaq -0x430(%rbp), %rax
movq %rax, -0x440(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x23a0
movq -0x440(%rbp), %rcx
movq %rax, %r8
leaq 0xf0de(%rip), %rdi      # 0x1e476
leaq 0xf099(%rip), %rsi      # 0x1e438
movl $0x154, %edx            # imm = 0x154
movb $0x0, %al
callq 0x117c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf3e2
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %edx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x2380
movq %rax, -0x438(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/tnef/tnef.c
// Function: default_handler
int default_handler(uint32 attribute, uint8 *tsp, uint32 size)
{
	uint16 type = ATT_TYPE(attribute);

	switch (type) {
		case atpTriples:
			break;
		case atpString:
		case atpText:
			break;
		case atpDate:
			break;
		case atpShort:
			break;
		case atpLong:
			break;
		case atpByte:
			break;
		case atpWord:
			break;
		case atpDword:
			break;
		default:
			break;
	}
	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movw -0x2(%rbp), %ax
movw %ax, -0x16(%rbp)
movzwl -0x16(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x8, %rax
ja 0xf7d8
movq -0x20(%rbp), %rax
leaq 0xec0d(%rip), %rcx      # 0x1e3cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xf7da
jmp 0xf7da
jmp 0xf7da
jmp 0xf7da
jmp 0xf7da
jmp 0xf7da
jmp 0xf7da
jmp 0xf7da
jmp 0xf7da
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/rawget.c
// Function: RAWGET_get
int RAWGET_get( unsigned char *buffer, int max, FILE *f )
{

	unsigned char c;					// read buffer
	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.

	//

	// Whilst we've got less bytes than the maximum availabe
	// for the buffer, we keep on reading
	//
	while (count < max)
	{
		// If we do infact read in 1 bytes...
		if (fread(&c,1,1,f)==1)
		{

			*buffer = c;		// Set the byte in the buffer
			buffer++;			// move the buffer pointer
			count++;				// Increment the byte cound

			if (c == '\n')		// If we encounter a \n (or \r)
			{
				break;			// Hop out of while loop
			}
		}
		else break;				// if we didn't read right, then jump out as well
	}

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1052c
movq -0x18(%rbp), %rcx
leaq -0x19(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x20b0
cmpq $0x1, %rax
jne 0x10528
movb -0x19(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0xa, %eax
jne 0x10526
jmp 0x1052c
jmp 0x1052a
jmp 0x1052c
jmp 0x104da
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/pldstr.c
// Function: PLD_strstr
char *PLD_strstr(char *haystack, char *needle, int insensitive)
{
    char *hs, *ne;
    char *result;

//  LOGGER_log("%s:%d:\nHS=%s\nNE=%s\nIS=%d\n",FL, haystack, needle, insensitive );

    if (insensitive > 0)
    {
        hs = strdup(haystack);
        PLD_strlower(hs);
        ne = strdup(needle);
        PLD_strlower(ne);
    } else {
        hs = haystack;
        ne = needle;
    }

    result = strstr(hs, ne);
//  if (result) LOGGER_log("%s:%d:HIT: %s",FL, result);
//  else LOGGER_log("%s:%d:MISS (looking for %s|%s)",FL, needle,ne);

    if ((result != NULL)&&(insensitive > 0))
    {
        result = result -hs +haystack;
//      free(hs);
//      free(ne);

//      LOGGER_log("%s:%d:HIT - %s",FL, result );
    }
    if (insensitive) {
        free(hs);
        free(ne);
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x10587
movq -0x8(%rbp), %rdi
callq 0x2390
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x105f0
movq -0x10(%rbp), %rdi
callq 0x2390
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x105f0
jmp 0x10597
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x23b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x105c8
cmpl $0x0, -0x14(%rbp)
jle 0x105c8
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
addq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x105e0
movq -0x20(%rbp), %rdi
callq 0x2030
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/pldstr.c
// Function: PLD_strncpy
char *PLD_strncpy (char *dst, const char *src, size_t len)
{
    // Thanks go to 'defrost' of #c for providing the replacement
    //      code which you now see here.  It covers the errors better
    //      than my own previous code.

    // If we have no buffer space, then it's futile attempting
    //      to copy anything, just return NULL
    if (len==0) return NULL;

    // Providing our destination pointer isn't NULL, we can
    //      commence copying data across

    if (dst)
    {
        char *dp = dst;
        // If our source string exists, start moving it to the
        //      destination string character at a time.
        if (src)
        {
            char *sp = (char *)src;
            while ((--len)&&(*sp)) { *dp=*sp; dp++; sp++; }
        }
        *dp='\0';
    }
    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10664
movq $0x0, -0x8(%rbp)
jmp 0x106e9
cmpq $0x0, -0x10(%rbp)
je 0x106e1
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x106da
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x31(%rbp)
je 0x106a9
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x106b2
jmp 0x106d8
movq -0x30(%rbp), %rax
movb (%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x10682
jmp 0x106da
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/pldstr.c
// Function: PLD_strncat
char *PLD_strncat( char *dst, const char *src, size_t len )
{
    char *dp = dst;
    const char *sp = src;
    size_t cc;

    if (len == 0) return dst;
    len--;
    // Locate the end of the current string.
    cc = 0;
    while ((*dp)&&(cc < len)) { dp++; cc++; }
    // If we have no more buffer space, then return the destination
    if (cc >= len) return dst;

    // While we have more source, and there's more char space left in the buffer
    while ((*sp)&&(cc < len))
    {
        cc++;
        *dp = *sp;
        dp++;
        sp++;
    }

    // Terminate dst, as a gaurantee of string ending.
    *dp = '\0';
    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10724
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x107f9
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x10757
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x10760
jmp 0x1077a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x10738
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x1078e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x107f9
jmp 0x10790
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3a(%rbp)
je 0x107af
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x107b8
jmp 0x107ea
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movb (%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x10790
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/pldstr.c
// Function: PLD_strncate
char *PLD_strncate( char *dst, const char *src, size_t len, char *endpoint )
{
    char *dp = dst;
    const char *sp = src;
    size_t cc = 0;

    if (len == 0) return dst;
    len--;
    // If endpoint does not relate correctly, then force manual detection
    // of the endpoint.

    if ((!endpoint)||(endpoint == dst)||((endpoint -dst +1)>(int)len))
    {
        // Locate the end of the current string.
        cc = 0;
        while ((*dp != '\0')&&(cc < len)) { dp++; cc++; }
    }
    else {
        cc = endpoint -dst +1;
        dp = endpoint;
    }

    // If we have no more buffer space, then return the destination
    if (cc >= len) return dst;
    // While we have more source, and there's more char space left in the buffer
    while ((*sp)&&(cc < len))
    {
        cc++;
        *dp = *sp;
        dp++;
        sp++;
    }
    // Terminate dst, as a gaurantee of string ending.
    *dp = '\0';
    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10840
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1095e
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x10878
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x10878
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movq -0x20(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jle 0x108c4
movq $0x0, -0x40(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
je 0x1089f
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x108a8
jmp 0x108c2
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x10880
jmp 0x108df
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x108f3
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1095e
jmp 0x108f5
movq -0x38(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x42(%rbp)
je 0x10914
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x1091d
jmp 0x1094f
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movb (%rax), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x108f5
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/pldstr.c
// Function: PLD_strncasecmp
int PLD_strncasecmp( char *s1, char *s2, int n )
{
    char *ds1 = s1, *ds2 = s2;
    char c1, c2;
    int result = 0;

    while(n > 0)
    {
        c1 = tolower(*ds1);
        c2 = tolower(*ds2);

        if (c1 == c2)
        {
            n--;
            ds1++;
            ds2++;
        }
        else
        {
            result = c2 - c1;
            n = 0;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x10a03
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x2280
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %edi
callq 0x2280
movb %al, -0x2a(%rbp)
movsbl -0x29(%rbp), %eax
movsbl -0x2a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x109ed
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x10a01
movsbl -0x2a(%rbp), %eax
movsbl -0x29(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
jmp 0x1099a
movl -0x30(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/pldstr.c
// Function: PLD_strreplace
char *PLD_strreplace( char **source, char *searchfor, char *replacewith, int replacenumber )
{
    struct PLD_strreplace replace_details;
    char *tmp_source;

    replace_details.source = *source;
    replace_details.searchfor = searchfor;
    replace_details.replacewith = replacewith;
    replace_details.replacenumber = replacenumber;
    replace_details.preexist = NULL;
    replace_details.postexist = NULL;
    replace_details.insensitive = 0;

    tmp_source = PLD_strreplace_general( &replace_details );

    if (tmp_source != *source) *source = tmp_source;
    return *source;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x10bc0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x11314
movq -0x58(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/logger.c
// Function: LOGGER_set_logfile
int LOGGER_set_logfile( char *lfname )
{
	int result = 0;

	_LOGGER_outf = fopen(lfname,"a");
	if (!_LOGGER_outf)
	{
#ifndef WIN32
		syslog(1,"LOGGER_set_logfile: ERROR - Cannot open logfile '%s' (%s)",lfname,strerror(errno));
#else
		fprintf(stderr, "LOGGER_set_logfile: ERROR - Cannot open logfile '%s' (%s)\n", lfname, strerror(errno));
#endif
		result = -1;
	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1050c(%rip), %rsi     # 0x21a1a
callq 0x2330
movq %rax, 0x24406(%rip)     # 0x35920
cmpq $0x0, 0x243fe(%rip)     # 0x35920
jne 0x11559
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x23a0
movq -0x18(%rbp), %rdx
movq %rax, %rcx
movl $0x1, %edi
leaq 0xd53d(%rip), %rsi      # 0x1ea88
movb $0x0, %al
callq 0x22d0
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/libmime-decoders.c
// Function: MDECODE_init
int MDECODE_init( void )
{
    glb.debug = 0;
    glb.verbose = 0;
    glb.decode_qp = 1;
    glb.decode_b64 = 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x23eb2(%rip)     # 0x35930
movl $0x0, 0x23eac(%rip)     # 0x35934
movl $0x1, 0x23ea6(%rip)     # 0x35938
movl $0x1, 0x23ea0(%rip)     # 0x3593c
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/boundary-stack.c
// Function: BS_init
int BS_init( void )
{
	glb.debug = 0;
	glb.verbose = 0;
	glb.syslogging = 1;
	glb.errlogging = 0;
	glb.count = 0;
	glb.detect_limit = BS_BOUNDARY_DETECT_LIMIT_DEFAULT;
	glb.hold_limit = 0;
	glb.boundarystack = NULL;
	glb.smallest_length = -1;
	glb.have_empty_boundary = 0;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x23232(%rip)     # 0x35940
movl $0x0, 0x2322c(%rip)     # 0x35944
movl $0x1, 0x23226(%rip)     # 0x35948
movl $0x0, 0x23220(%rip)     # 0x3594c
movl $0x0, 0x2321a(%rip)     # 0x35950
movl $0x4, 0x23214(%rip)     # 0x35954
movl $0x0, 0x2320e(%rip)     # 0x35958
movq $0x0, 0x23213(%rip) # 0x35968
movl $0xffffffff, 0x231fd(%rip) # imm = 0xFFFFFFFF
movl $0x0, 0x231f7(%rip)     # 0x35960
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/boundary-stack.c
// Function: BS_clear
int BS_clear( void )
{
	struct BS_node *next;

	while (glb.boundarystack)
	{
		DBS LOGGER_log("%s:%d:BS_clear:DEBUG: Popping off %p",FL,glb.boundarystack);
		next = glb.boundarystack->next;
		free(glb.boundarystack->boundary);
		free(glb.boundarystack);
		glb.boundarystack = next;
	}

	glb.boundarystack = NULL;
	glb.count = 0;
	glb.smallest_length = -1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x23158(%rip)     # 0x35968
je 0x12873
cmpl $0x0, 0x23127(%rip)     # 0x35940
je 0x1283c
movq 0x23146(%rip), %rcx     # 0x35968
leaq 0xc784(%rip), %rdi      # 0x1efad
leaq 0xc7a2(%rip), %rsi      # 0x1efd2
movl $0xc0, %edx
movb $0x0, %al
callq 0x117c0
movq 0x23125(%rip), %rax     # 0x35968
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq 0x23116(%rip), %rax     # 0x35968
movq (%rax), %rdi
callq 0x2030
movq 0x23107(%rip), %rdi     # 0x35968
callq 0x2030
movq -0x8(%rbp), %rax
movq %rax, 0x230f7(%rip)     # 0x35968
jmp 0x12808
movq $0x0, 0x230ea(%rip) # 0x35968
movl $0x0, 0x230c8(%rip)     # 0x35950
movl $0xffffffff, 0x230ca(%rip) # imm = 0xFFFFFFFF
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/boundary-stack.c
// Function: BS_non_hyphen_length
int BS_non_hyphen_length( char *boundary )
{
	int count = 0;
	char *p = boundary;

	while (*p) { if (isalnum((int)*p)) count++; p++; };

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x128f9
callq 0x23c0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x128eb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x128bb
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/boundary-stack.c
// Function: BS_pop
char *BS_pop( void )
{

	struct BS_node *node = glb.boundarystack;

	if (glb.boundarystack)
	{
		glb.boundarystack = glb.boundarystack->next;
		PLD_strncpy(glb.boundarystacksafe,node->boundary, BS_STRLEN_MAX);
		free(node->boundary);
		free(node);
		glb.count--;
	}

	return glb.boundarystacksafe;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x22e69(%rip), %rax     # 0x35968
movq %rax, -0x8(%rbp)
cmpq $0x0, 0x22e5d(%rip)     # 0x35968
je 0x12b5f
movq 0x22e54(%rip), %rax     # 0x35968
movq 0x10(%rax), %rax
movq %rax, 0x22e49(%rip)     # 0x35968
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x22e13(%rip), %rdi     # 0x35940
addq $0x30, %rdi
movl $0x400, %edx            # imm = 0x400
callq 0x10640
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
movl 0x22dfa(%rip), %eax     # 0x35950
addl $-0x1, %eax
movl %eax, 0x22df1(%rip)     # 0x35950
leaq 0x22dda(%rip), %rax     # 0x35940
addq $0x30, %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/uuencode.c
// Function: UUENCODE_init
int UUENCODE_init( void )
{
	glb.debug = 0;
	glb.verbosity = 0;
	glb.verbosity_contenttype = 0;
	glb.decode = 1;
	glb.doubleCR_mode = 0;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x22cc2(%rip)     # 0x35d70
movl $0x0, 0x22cbc(%rip)     # 0x35d74
movl $0x0, 0x22cb6(%rip)     # 0x35d78
movl $0x1, 0x22cb0(%rip)     # 0x35d7c
movl $0x0, 0x22caa(%rip)     # 0x35d80
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)