LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sundale[P]gcode/inifile.cc
// Function: IniFile::TildeExpansion(char const*, char*)
void
IniFile::TildeExpansion(const char *file, char *path)
{
    char                        *home;

    strncpy(path, file, LINELEN);
    if (strlen(file) < 2 || !(file[0] == '~' && file[1] == '/')) {
	/* no tilde expansion required, or unsupported
           tilde expansion type requested */
	return;
    }

    home = getenv("HOME");
    if (!home || strlen(home) + strlen(file) > LINELEN) {
	return;
    }

    /* Buffer overflow has already been checked. */

    strcpy(path, home);
    strcat(path, file + 1);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xff, %edx
callq 0x40d0
movq -0x10(%rbp), %rdi
callq 0x40a0
cmpq $0x2, %rax
jb 0x520e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jne 0x520e
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x5210
jmp 0x526f
leaq 0x5ecb(%rip), %rdi      # 0xb0e2
callq 0x4200
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x524f
movq -0x20(%rbp), %rdi
callq 0x40a0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x40a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
cmpq $0xff, %rax
jbe 0x5251
jmp 0x526f
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4170
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
callq 0x42f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/inifile.cc
// Function: IniFile::Find(int*, int, int, char const*, char const*, int)
IniFile::ErrorCode                   
IniFile::Find(int *result, int min, int max,
              const char *tag, const char *section, int num)
{
    ErrorCode                   errCode;
    int                         tmp;

    if((errCode = Find(&tmp, tag, section, num)) != ERR_NONE)
        return(errCode);

    if((tmp > max) || (tmp < min))
        return(ERR_LIMITS);

    *result = tmp;

    return(ERR_NONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl 0x10(%rbp), %r8d
leaq -0x38(%rbp), %rsi
callq 0x5300
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x52ca
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x52f3
movl -0x38(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x52da
movl -0x38(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x52e3
movl $0x10, -0x4(%rbp)
jmp 0x52f3
movl -0x38(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sundale[P]gcode/inifile.cc
// Function: IniFile::Find(int*, char const*, char const*, int)
IniFile::ErrorCode                   
IniFile::Find(int *result, const char *tag, const char *section, int num)
{
    const char                  *pStr;
    int                         tmp;

    if((pStr = Find(tag, section, num)) == NULL){
        // We really need an ErrorCode return from Find() and should be passing
        // in a buffer. Just pick a suitable ErrorCode for now.
        return(ERR_TAG_NOT_FOUND);
    }

    if(sscanf(pStr, "%i", &tmp) != 1){
        ThrowException(ERR_CONVERSION);
        return(ERR_CONVERSION);
    }

    *result = tmp;

    return(ERR_NONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x53a0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x5347
movl $0x4, -0x4(%rbp)
jmp 0x5389
movq -0x38(%rbp), %rdi
leaq 0x5d84(%rip), %rsi      # 0xb0d6
leaq -0x3c(%rbp), %rdx
movb $0x0, %al
callq 0x4180
cmpl $0x1, %eax
je 0x5379
movq -0x48(%rbp), %rdi
movl $0x8, %esi
callq 0x5900
movl $0x8, -0x4(%rbp)
jmp 0x5389
movl -0x3c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/inifile.cc
// Function: IniFile::ThrowException(IniFile::ErrorCode)
void
IniFile::ThrowException(ErrorCode errCode)
{
    if(errCode & errMask){
        exception.errCode = errCode;
        exception.tag = tag;
        exception.section = section;
        exception.num = num;
        exception.lineNo = lineNo;
        throw(exception);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl 0x50(%rcx), %eax
cmpl $0x0, %eax
je 0x5988
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x30(%rax)
movq 0x58(%rax), %rcx
movq %rcx, 0x38(%rax)
movq 0x60(%rax), %rcx
movq %rcx, 0x40(%rax)
movl 0x68(%rax), %ecx
movl %ecx, 0x48(%rax)
movl 0x54(%rax), %ecx
movl %ecx, 0x4c(%rax)
movl $0x20, %edi
callq 0x40c0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
movq %rcx, (%rdi)
movq 0x38(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq 0x40(%rax), %rcx
movq %rcx, 0x10(%rdi)
movq 0x48(%rax), %rax
movq %rax, 0x18(%rdi)
leaq 0x93f9(%rip), %rsi      # 0xed78
xorl %eax, %eax
movl %eax, %edx
callq 0x42c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: sundale[P]gcode/inifile.cc
// Function: IniFile::Find(double*, double, double, char const*, char const*, int)
IniFile::ErrorCode                   
IniFile::Find(double *result, double min, double max,
              const char *tag, const char *section, int num)
{
    ErrorCode                   errCode;
    double                      tmp;

    if((errCode = Find(&tmp, tag, section, num)) != ERR_NONE)
        return(errCode);

    if((tmp > max) || (tmp < min))
        return(ERR_LIMITS);

    *result = tmp;

    return(ERR_NONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movl %r8d, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl -0x3c(%rbp), %r8d
leaq -0x48(%rbp), %rsi
callq 0x5a30
movl %eax, -0x40(%rbp)
cmpl $0x0, %eax
je 0x59df
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5a18
movsd -0x48(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
ja 0x59fb
movsd -0x48(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5a04
movl $0x10, -0x4(%rbp)
jmp 0x5a18
movsd -0x48(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/inifile.cc
// Function: IniFile::Find(double*, char const*, char const*, int)
IniFile::ErrorCode                   
IniFile::Find(double *result, const char *tag, const char *section, int num)
{
    const char                  *pStr;
    double                      tmp;

    if((pStr = Find(tag, section, num)) == NULL){
        // We really need an ErrorCode return from Find() and should be passing
        // in a buffer. Just pick a suitable ErrorCode for now.
        return(ERR_TAG_NOT_FOUND);
    }

    if(sscanf(pStr, "%lf", &tmp) != 1){
        ThrowException(ERR_CONVERSION);
        return(ERR_CONVERSION);
    }

    *result = tmp;

    return(ERR_NONE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x53a0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x5a77
movl $0x4, -0x4(%rbp)
jmp 0x5abd
movq -0x38(%rbp), %rdi
leaq 0x5657(%rip), %rsi      # 0xb0d9
leaq -0x40(%rbp), %rdx
movb $0x0, %al
callq 0x4180
cmpl $0x1, %eax
je 0x5aa9
movq -0x48(%rbp), %rdi
movl $0x8, %esi
callq 0x5900
movl $0x8, -0x4(%rbp)
jmp 0x5abd
movsd -0x40(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/inifile.cc
// Function: IniFile::Find(int*, IniFile::StrIntPair*, char const*, char const*, int)
IniFile::ErrorCode
IniFile::Find(int *result, StrIntPair *pPair,
     const char *tag, const char *section, int num)
{
    const char                  *pStr;
    int                         tmp;

    if((pStr = Find(tag, section, num)) == NULL){
        // We really need an ErrorCode return from Find() and should be passing
        // in a buffer. Just pick a suitable ErrorCode for now.
        return(ERR_TAG_NOT_FOUND);
    }

    if(sscanf(pStr, "%i", &tmp) == 1){
        *result = tmp;
        return(ERR_NONE);
    }

    while(pPair->pStr != NULL){
        if(strcasecmp(pStr, pPair->pStr) == 0){
            *result = pPair->value;
            return(ERR_NONE);
        }
        pPair++;
    }

    ThrowException(ERR_CONVERSION);
    return(ERR_CONVERSION);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x34(%rbp), %ecx
callq 0x53a0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x5b1e
movl $0x4, -0x4(%rbp)
jmp 0x5ba5
movq -0x40(%rbp), %rdi
leaq 0x55ad(%rip), %rsi      # 0xb0d6
leaq -0x44(%rbp), %rdx
movb $0x0, %al
callq 0x4180
cmpl $0x1, %eax
jne 0x5b4b
movl -0x44(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5ba5
jmp 0x5b4d
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5b90
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x41c0
cmpl $0x0, %eax
jne 0x5b82
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5ba5
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x5b4d
movq -0x50(%rbp), %rdi
movl $0x8, %esi
callq 0x5900
movl $0x8, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: sundale[P]gcode/inifile.cc
// Function: IniFile::Find(double*, IniFile::StrDoublePair*, char const*, char const*, int)
IniFile::ErrorCode
IniFile::Find(double *result, StrDoublePair *pPair,
     const char *tag, const char *section, int num)
{
    const char                  *pStr;
    double                      tmp;

    if((pStr = Find(tag, section, num)) == NULL){
        // We really need an ErrorCode return from Find() and should be passing
        // in a buffer. Just pick a suitable ErrorCode for now.
        return(ERR_TAG_NOT_FOUND);
    }

    if(sscanf(pStr, "%lf", &tmp) == 1){
        *result = tmp;
        return(ERR_NONE);
    }

    while(pPair->pStr != NULL){
        if(strcasecmp(pStr, pPair->pStr) == 0){
            *result = pPair->value;
            return(ERR_NONE);
        }
        pPair++;
    }

    ThrowException(ERR_CONVERSION);
    return(ERR_CONVERSION);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x34(%rbp), %ecx
callq 0x53a0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x5bfe
movl $0x4, -0x4(%rbp)
jmp 0x5c8d
movq -0x40(%rbp), %rdi
leaq 0x54d0(%rip), %rsi      # 0xb0d9
leaq -0x48(%rbp), %rdx
movb $0x0, %al
callq 0x4180
cmpl $0x1, %eax
jne 0x5c2f
movsd -0x48(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5c8d
jmp 0x5c31
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5c78
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x41c0
cmpl $0x0, %eax
jne 0x5c6a
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5c8d
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x5c31
movq -0x50(%rbp), %rdi
movl $0x8, %esi
callq 0x5900
movl $0x8, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/inifile.cc
// Function: IniFile::CheckIfOpen()
bool
IniFile::CheckIfOpen(void)
{
    if(IsOpen())
        return(true);

    ThrowException(ERR_NOT_OPEN);

    return(false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x6070
testb $0x1, %al
jne 0x5cbf
jmp 0x5cc5
movb $0x1, -0x1(%rbp)
jmp 0x5cd7
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x5900
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/inifile.cc
// Function: check_line_endings(char const*)
static bool check_line_endings(const char *s) {
    if(!s) return false;
    for(; *s; s++ ) {
        if(*s == '\r') {
            char c = s[1];
            if(c == '\n' || c == '\0') {
                static bool warned = 0;
                if(!warned) 
                    fprintf(stderr, "inifile: warning: File contains DOS-style line endings.\n");
                warned = true;
                continue;
            }
            fprintf(stderr, "inifile: error: File contains ambiguous carriage returns\n");
            return true;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5d0c
movb $0x0, -0x1(%rbp)
jmp 0x5da2
jmp 0x5d0e
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5d9e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0x5d8b
movq -0x10(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
je 0x5d43
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0x5d6d
testb $0x1, 0xa5b7(%rip)      # 0x10301
jne 0x5d64
movq 0x928d(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x541e(%rip), %rsi      # 0xb17b
movb $0x0, %al
callq 0x4260
movb $0x1, 0xa596(%rip)      # 0x10301
jmp 0x5d8d
movq 0x926c(%rip), %rax      # 0xefe0
movq (%rax), %rdi
leaq 0x5436(%rip), %rsi      # 0xb1b4
movb $0x0, %al
callq 0x4260
movb $0x1, -0x1(%rbp)
jmp 0x5da2
jmp 0x5d8d
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5d0e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sundale[P]gcode/inifile.cc
// Function: IniFile::SkipWhite(char const*)
char *
IniFile::SkipWhite(const char *string)
{
    while(true){
        if (*string == 0) {
            return(NULL);
        }

        if ((*string == ';') || (*string == '#')) {
            return(NULL);
        }

        if (*string != ' ' && *string != '\t' && *string != '\r'
            && *string != '\n') {
            return((char *)string);
        }

        string++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5dd2
movq $0x0, -0x8(%rbp)
jmp 0x5e3c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
je 0x5dea
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x5df4
movq $0x0, -0x8(%rbp)
jmp 0x5e3c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x5e2e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
je 0x5e2e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
je 0x5e2e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x5e2e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5e3c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5dbc
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/inifile.cc
// Function: IniFile::AfterEqual(char const*)
char *
IniFile::AfterEqual(const char *string)
{
    const char                  *spot = string;

    for (;;) {
        if (*spot == '=') {
            /* = is there-- return next non-white, or NULL if not there */
            for (;;) {
                spot++;
                if (0 == *spot) {
                    /* ran out */
                    return(NULL);
                } else if (*spot != ' ' && *spot != '\t' && *spot != '\r'
                           && *spot != '\n') {
                    /* matched! */
                    return((char *)spot);
                } else {
                    /* keep going for the text */
                    continue;
                }
            }
        } else if (*spot == 0) {
            /* end of string */
            return(NULL);
        } else {
            /* haven't seen '=' yet-- keep going */
            spot++;
            continue;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x5ed1
jmp 0x5e72
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x5e95
movq $0x0, -0x8(%rbp)
jmp 0x5ef8
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x5ecf
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
je 0x5ecf
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
je 0x5ecf
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x5ecf
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5ef8
jmp 0x5e72
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5ee7
movq $0x0, -0x8(%rbp)
jmp 0x5ef8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5e64
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: sundale[P]gcode/inifile.cc
// Function: IniFile::Exception::Print(_IO_FILE*)
void
IniFile::Exception::Print(FILE *fp)
{
    const char                  *msg;

    switch(errCode){
    case ERR_NONE:
        msg = "ERR_NONE";
        break;

    case ERR_NOT_OPEN:
        msg = "ERR_NOT_OPEN";
        break;

    case ERR_SECTION_NOT_FOUND:
        msg = "ERR_SECTION_NOT_FOUND";
        break;

    case ERR_TAG_NOT_FOUND:
        msg = "ERR_TAG_NOT_FOUND";
        break;

    case ERR_CONVERSION:
        msg = "ERR_CONVERSION";
        break;

    case ERR_LIMITS:
        msg = "ERR_LIMITS";
        break;

    default:
        msg = "UNKNOWN";
    }

    fprintf(fp, "INIFILE: %s, section=%s, tag=%s, num=%d, lineNo=%d\n",
            msg, section, tag, num, lineNo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x10, %rax
ja 0x5f86
movq -0x20(%rbp), %rax
leaq 0x5161(%rip), %rcx      # 0xb090
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x51a8(%rip), %rax      # 0xb0e7
movq %rax, -0x18(%rbp)
jmp 0x5f91
leaq 0x51a4(%rip), %rax      # 0xb0f0
movq %rax, -0x18(%rbp)
jmp 0x5f91
leaq 0x51a4(%rip), %rax      # 0xb0fd
movq %rax, -0x18(%rbp)
jmp 0x5f91
leaq 0x51ad(%rip), %rax      # 0xb113
movq %rax, -0x18(%rbp)
jmp 0x5f91
leaq 0x51b2(%rip), %rax      # 0xb125
movq %rax, -0x18(%rbp)
jmp 0x5f91
leaq 0x51b4(%rip), %rax      # 0xb134
movq %rax, -0x18(%rbp)
jmp 0x5f91
leaq 0x51b2(%rip), %rax      # 0xb13f
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq 0x10(%rax), %rcx
movq 0x8(%rax), %r8
movl 0x18(%rax), %r9d
movl 0x1c(%rax), %eax
leaq 0x5194(%rip), %rsi      # 0xb147
movl %eax, (%rsp)
movb $0x0, %al
callq 0x4260
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/saicanon.cc
// Function: print_nc_line_number()
void print_nc_line_number()
{
  char text[256];
  int k;
  int m;

  if(NULL == _outfile)
    {
      _outfile = stdout;
    }

  interp_new.line_text(text, 256);
  for (k = 0;
       ((k < 256) &&
        ((text[k] == '\t') || (text[k] == ' ') || (text[k] == '/')));
       k++);
  if ((k < 256) && ((text[k] == 'n') || (text[k] == 'N')))
    {
      fputc('N', _outfile);
      for (k++, m = 0;
           ((k < 256) && (text[k] >= '0') && (text[k] <= '9'));
           k++, m++)
        fputc(text[k], _outfile);
      for (; m < 6; m++)
        fputc(' ', _outfile);
    }
  else if (k < 256)
    fprintf(_outfile, "N..... ");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
xorl %eax, %eax
cmpq 0xa22c(%rip), %rax      # 0x10310
jne 0x60f7
movq 0x8ecb(%rip), %rax      # 0xefb8
movq (%rax), %rax
movq %rax, 0xa219(%rip)      # 0x10310
leaq -0x100(%rbp), %rsi
leaq 0x90eb(%rip), %rdi      # 0xf1f0
movl $0x100, %edx            # imm = 0x100
callq 0x4280
movl $0x0, -0x104(%rbp)
xorl %eax, %eax
cmpl $0x100, -0x104(%rbp)    # imm = 0x100
movb %al, -0x109(%rbp)
jge 0x618c
movslq -0x104(%rbp), %rax
movsbl -0x100(%rbp,%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x10a(%rbp)
je 0x6180
movslq -0x104(%rbp), %rax
movsbl -0x100(%rbp,%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x10a(%rbp)
je 0x6180
movslq -0x104(%rbp), %rax
movsbl -0x100(%rbp,%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x10a(%rbp)
movb -0x10a(%rbp), %al
movb %al, -0x109(%rbp)
movb -0x109(%rbp), %al
testb $0x1, %al
jne 0x6198
jmp 0x61ae
jmp 0x619a
movl -0x104(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x104(%rbp)
jmp 0x6119
cmpl $0x100, -0x104(%rbp)    # imm = 0x100
jge 0x62d8
movslq -0x104(%rbp), %rax
movsbl -0x100(%rbp,%rax), %eax
cmpl $0x6e, %eax
je 0x61ea
movslq -0x104(%rbp), %rax
movsbl -0x100(%rbp,%rax), %eax
cmpl $0x4e, %eax
jne 0x62d8
movq 0xa11f(%rip), %rsi      # 0x10310
movl $0x4e, %edi
callq 0x4210
movl -0x104(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x104(%rbp)
movl $0x0, -0x108(%rbp)
xorl %eax, %eax
cmpl $0x100, -0x104(%rbp)    # imm = 0x100
movb %al, -0x10b(%rbp)
jge 0x625f
movslq -0x104(%rbp), %rax
movsbl -0x100(%rbp,%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x10b(%rbp)
jl 0x625f
movslq -0x104(%rbp), %rax
movsbl -0x100(%rbp,%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x10b(%rbp)
movb -0x10b(%rbp), %al
testb $0x1, %al
jne 0x626b
jmp 0x62a9
movslq -0x104(%rbp), %rax
movsbl -0x100(%rbp,%rax), %edi
movq 0xa08f(%rip), %rsi      # 0x10310
callq 0x4210
movl -0x104(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x104(%rbp)
movl -0x108(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x108(%rbp)
jmp 0x6214
jmp 0x62ab
cmpl $0x6, -0x108(%rbp)
jge 0x62d6
movq 0xa055(%rip), %rsi      # 0x10310
movl $0x20, %edi
callq 0x4210
movl -0x108(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x108(%rbp)
jmp 0x62ab
jmp 0x62fb
cmpl $0x100, -0x104(%rbp)    # imm = 0x100
jge 0x62f9
movq 0xa025(%rip), %rdi      # 0x10310
leaq 0x4f3e(%rip), %rsi      # 0xb230
movb $0x0, %al
callq 0x4260
jmp 0x62fb
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/saicanon.cc
// Function: SET_XY_ROTATION(double)
void SET_XY_ROTATION(double t) {
  fprintf(_outfile, "%5d ", _line_number++);
  print_nc_line_number();
  fprintf(_outfile, "SET_XY_ROTATION(%.4f)\n", t);
  // CJR XXX 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
movq 0x9fec(%rip), %rdi      # 0x10310
movl 0x8e8a(%rip), %edx      # 0xf1b4
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x8e7f(%rip)      # 0xf1b4
leaq 0x4efc(%rip), %rsi      # 0xb238
movb $0x0, %al
callq 0x4260
callq 0x60d0
movq 0x9fc1(%rip), %rdi      # 0x10310
movsd -0x8(%rbp), %xmm0
leaq 0x4ee2(%rip), %rsi      # 0xb23d
movb $0x1, %al
callq 0x4260
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sundale[P]gcode/saicanon.cc
// Function: STRAIGHT_TRAVERSE(int, double, double, double, double, double, double, double, double, double)
void STRAIGHT_TRAVERSE( int line_number,
 double x, double y, double z
 , double a /*AA*/
 , double b /*BB*/
 , double c /*CC*/
 , double u, double v, double w
)
{
  fprintf(_outfile, "%5d ", _line_number++);
  print_nc_line_number();
  fprintf(_outfile, "STRAIGHT_TRAVERSE(%.4f, %.4f, %.4f"
         ", %.4f" /*AA*/
         ", %.4f" /*BB*/
         ", %.4f" /*CC*/
         ")\n", x, y, z
         , a /*AA*/
         , b /*BB*/
         , c /*CC*/
         );
  line_demo(spi_fd, 
				get_pulse_x(x-_program_position_x),
				get_pulse_y(y-_program_position_y),
				get_pulse_z(z-_program_position_z));
  
  _program_position_x = x;
  _program_position_y = y;
  _program_position_z = z;
  _program_position_a = a; /*AA*/
  _program_position_b = b; /*BB*/
  _program_position_c = c; /*CC*/
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd 0x10(%rbp), %xmm8
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x38(%rbp)
movsd %xmm6, -0x40(%rbp)
movsd %xmm7, -0x48(%rbp)
movq 0x9a00(%rip), %rdi      # 0x10310
movl 0x889e(%rip), %edx      # 0xf1b4
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x8893(%rip)      # 0xf1b4
leaq 0x4910(%rip), %rsi      # 0xb238
movb $0x0, %al
callq 0x4260
callq 0x60d0
movq 0x99d5(%rip), %rdi      # 0x10310
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
movsd -0x30(%rbp), %xmm4
movsd -0x38(%rbp), %xmm5
leaq 0x49a8(%rip), %rsi      # 0xb308
movb $0x6, %al
callq 0x4260
leaq 0x887a(%rip), %rax      # 0xf1e8
movl (%rax), %eax
movl %eax, -0x54(%rbp)
movsd -0x10(%rbp), %xmm0
subsd 0xb290(%rip), %xmm0     # 0x11c10
cvtsd2ss %xmm0, %xmm0
callq 0x4d70
movl %eax, -0x50(%rbp)
movsd -0x18(%rbp), %xmm0
subsd 0xb287(%rip), %xmm0     # 0x11c20
cvtsd2ss %xmm0, %xmm0
callq 0x4da0
movl %eax, -0x4c(%rbp)
movsd -0x20(%rbp), %xmm0
subsd 0xb27e(%rip), %xmm0     # 0x11c30
cvtsd2ss %xmm0, %xmm0
callq 0x4dd0
movl -0x54(%rbp), %edi
movl -0x50(%rbp), %esi
movl -0x4c(%rbp), %edx
movl %eax, %ecx
callq 0x46d0
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0xb238(%rip)     # 0x11c10
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0xb23b(%rip)     # 0x11c20
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0xb23e(%rip)     # 0x11c30
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0xb241(%rip)     # 0x11c40
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0xb244(%rip)     # 0x11c50
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0xb247(%rip)     # 0x11c60
addq $0x60, %rsp
popq %rbp
retq
nop
// File: sundale[P]gcode/saicanon.cc
// Function: NURBS_FEED(int, std::vector<CONTROL_POINT, std::allocator<CONTROL_POINT>>, unsigned int)
void NURBS_FEED(int lineno,
std::vector<CONTROL_POINT> nurbs_control_points, unsigned int k)
{
  fprintf(_outfile, "%5d ", _line_number++);
  print_nc_line_number();
  fprintf(_outfile, "NURBS_FEED(%lu, ...)\n", (unsigned long)nurbs_control_points.size());

  _program_position_x = nurbs_control_points[nurbs_control_points.size()].X;
  _program_position_y = nurbs_control_points[nurbs_control_points.size()].Y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x9023(%rip), %rdi      # 0x10310
movl 0x7ec1(%rip), %edx      # 0xf1b4
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x7eb6(%rip)      # 0xf1b4
leaq 0x3f33(%rip), %rsi      # 0xb238
movb $0x0, %al
callq 0x4260
callq 0x60d0
movq -0x20(%rbp), %rdi
movq 0x8ff4(%rip), %rax      # 0x10310
movq %rax, -0x28(%rbp)
callq 0x9790
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x41fc(%rip), %rsi      # 0xb52f
movb $0x0, %al
callq 0x4260
movq -0x20(%rbp), %rdi
callq 0x9790
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x97c0
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0xa8b1(%rip)     # 0x11c10
callq 0x9790
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x97c0
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0xa8a3(%rip)     # 0x11c20
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/saicanon.cc
// Function: GET_EXTERNAL_PARAMETER_FILE_NAME(char*, int)
void GET_EXTERNAL_PARAMETER_FILE_NAME(
 char * file_name,       /* string: to copy file name into       */
 int max_size)           /* maximum number of characters to copy */
{
    // Paranoid checks
    if (0 == file_name)
	return;

    if (max_size < 0)
	return;

  if (strlen(_parameter_file_name) < (unsigned int)max_size)
    strcpy(file_name, _parameter_file_name);
  else
    file_name[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x93a9
jmp 0x93de
cmpl $0x0, -0xc(%rbp)
jge 0x93b1
jmp 0x93de
leaq 0x6f68(%rip), %rdi      # 0x10320
callq 0x40a0
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
jae 0x93d7
movq -0x8(%rbp), %rdi
leaq 0x6f50(%rip), %rsi      # 0x10320
callq 0x4170
jmp 0x93de
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/saicanon.cc
// Function: USER_DEFINED_FUNCTION_ADD(void (*)(int, double, double), int)
int USER_DEFINED_FUNCTION_ADD(USER_DEFINED_FUNCTION_TYPE func, int num)
{
  if (num < 0 || num >= USER_DEFINED_FUNCTION_NUM) {
    return -1;
  }

  USER_DEFINED_FUNCTION[num] = func;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x95f7
cmpl $0x64, -0x14(%rbp)
jl 0x9600
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x961a
movq -0x10(%rbp), %rdx
movslq -0x14(%rbp), %rcx
leaq 0x8721(%rip), %rax      # 0x11d30
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: afborchert[P]fmt/test_suite.cpp
// Function: diff_analysis(bool, char const*, int, int, char const*, char const*)
void diff_analysis(bool implementation_defined,
      const char* format, int count1, int count2,
      const char* buf1, const char* buf2) {
   if (implementation_defined) {
      print("implementation-dependent test for \"%s\" differs:\n", format);
   } else {
      print("test for \"%s\" fails:\n", format);
   }
   if (count1 == count2) {
      print("   fmt delivers: '%s'\n", buf1);
      print("   std delivers: '%s'\n", buf2);
   } else {
      print("   fmt delivers: '%s' (%d)\n", buf1, count1);
      print("   std delivers: '%s' (%d)\n", buf2, count2);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
testb $0x1, -0x1(%rbp)
je 0x8afa
leaq 0x6d859(%rip), %rdi     # 0x76348
leaq -0x10(%rbp), %rsi
callq 0xd250
jmp 0x8b0a
leaq 0x6e633(%rip), %rdi     # 0x77134
leaq -0x10(%rbp), %rsi
callq 0xd250
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x8b34
leaq 0x6d860(%rip), %rdi     # 0x76379
leaq -0x20(%rbp), %rsi
callq 0xd250
leaq 0x6d867(%rip), %rdi     # 0x76390
leaq -0x28(%rbp), %rsi
callq 0xd250
jmp 0x8b5c
leaq 0x6d86c(%rip), %rdi     # 0x763a7
leaq -0x20(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0xd280
leaq 0x6d874(%rip), %rdi     # 0x763c3
leaq -0x28(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xd280
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: afborchert[P]fmt/test_suite.cpp
// Function: diff_analysis(bool, wchar_t const*, int, int, wchar_t const*, wchar_t const*)
void diff_analysis(bool implementation_defined,
      const wchar_t* format, int count1, int count2,
      const wchar_t* buf1, const wchar_t* buf2) {
   if (implementation_defined) {
      print(L"implementation-dependent test for L\"%s\" differs:\n", format);
   } else {
      print(L"test for L\"%s\" fails:\n", format);
   }
   if (count1 == count2) {
      print(L"   fmt delivers: '%s'\n", buf1);
      print(L"   std delivers: '%s'\n", buf2);
   } else {
      print(L"   fmt delivers: '%s' (%d)\n", buf1, count1);
      print(L"   std delivers: '%s' (%d)\n", buf2, count2);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
testb $0x1, -0x1(%rbp)
je 0x8baa
leaq 0x6e629(%rip), %rdi     # 0x771c8
leaq -0x10(%rbp), %rsi
callq 0xd2c0
jmp 0x8bba
leaq 0x6e6df(%rip), %rdi     # 0x77290
leaq -0x10(%rbp), %rsi
callq 0xd2c0
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x8be4
leaq 0x6e723(%rip), %rdi     # 0x772ec
leaq -0x20(%rbp), %rsi
callq 0xd2c0
leaq 0x6e76f(%rip), %rdi     # 0x77348
leaq -0x28(%rbp), %rsi
callq 0xd2c0
jmp 0x8c0c
leaq 0x6e7b9(%rip), %rdi     # 0x773a4
leaq -0x20(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0xd2f0
leaq 0x6e815(%rip), %rdi     # 0x77414
leaq -0x28(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xd2f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: afborchert[P]fmt/test_suite.cpp
// Function: count_mismatch(bool, char const*, int, int)
void count_mismatch(bool implementation_defined,
      const char* format, int count1, int count2) {
   if (implementation_defined) {
      print("implementation-dependent test for \"%s\" differs,", format);
   } else {
      print("test for \"%s\" fails,", format);
   }
   print(" fmt returns %d, std returns %d\n",
      count1, count2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
testb $0x1, -0x1(%rbp)
je 0x8cb2
leaq 0x6d76c(%rip), %rdi     # 0x76413
leaq -0x10(%rbp), %rsi
callq 0xd250
jmp 0x8cc2
leaq 0x6e43a(%rip), %rdi     # 0x770f3
leaq -0x10(%rbp), %rsi
callq 0xd250
leaq 0x6d77a(%rip), %rdi     # 0x76443
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xd3b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: afborchert[P]fmt/test_suite.cpp
// Function: count_mismatch(bool, wchar_t const*, int, int)
void count_mismatch(bool implementation_defined,
      const wchar_t* format, int count1, int count2) {
   if (implementation_defined) {
      print(L"implementation-dependent test for \"%s\" differs,", format);
   } else {
      print(L"test for \"%s\" fails,", format);
   }
   print(L" fmt returns %d, std returns %d\n",
      count1, count2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
testb $0x1, -0x1(%rbp)
je 0x8d12
leaq 0x6e84d(%rip), %rdi     # 0x77554
leaq -0x10(%rbp), %rsi
callq 0xd2c0
jmp 0x8d22
leaq 0x6e8fb(%rip), %rdi     # 0x77614
leaq -0x10(%rbp), %rsi
callq 0xd2c0
leaq 0x6e93f(%rip), %rdi     # 0x77668
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xd3f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: afborchert[P]fmt/test_suite.cpp
// Function: errno_mismatch(bool, char const*, int, int)
void errno_mismatch(bool implementation_defined,
      const char* format, int err1, int err2) {
   if (implementation_defined) {
      print("implementation-dependent test for \"%s\" differs,", format);
   } else {
      print("test for \"%s\" fails,", format);
   }
   print(" fmt sets errno to %d, std sets errno to %d\n",
      err1, err2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
testb $0x1, -0x1(%rbp)
je 0x8d72
leaq 0x6d6ac(%rip), %rdi     # 0x76413
leaq -0x10(%rbp), %rsi
callq 0xd250
jmp 0x8d82
leaq 0x6e37a(%rip), %rdi     # 0x770f3
leaq -0x10(%rbp), %rsi
callq 0xd250
leaq 0x6d6db(%rip), %rdi     # 0x76464
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xd3b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: afborchert[P]fmt/test_suite.cpp
// Function: errno_mismatch(bool, wchar_t const*, int, int)
void errno_mismatch(bool implementation_defined,
      const wchar_t* format, int err1, int err2) {
   if (implementation_defined) {
      print(L"implementation-dependent test for \"%s\" differs,", format);
   } else {
      print(L"test for \"%s\" fails,", format);
   }
   print(L" fmt sets errno to %d, std sets errno to %d\n",
      err1, err2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
testb $0x1, -0x1(%rbp)
je 0x8dd2
leaq 0x6e78d(%rip), %rdi     # 0x77554
leaq -0x10(%rbp), %rsi
callq 0xd2c0
jmp 0x8de2
leaq 0x6e83b(%rip), %rdi     # 0x77614
leaq -0x10(%rbp), %rsi
callq 0xd2c0
leaq 0x6e903(%rip), %rdi     # 0x776ec
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xd3f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: afborchert[P]fmt/test_suite.cpp
// Function: check_hexfloat()
bool check_hexfloat() {
   std::ostringstream os;
   os.setf(std::ios_base::scientific | std::ios_base::fixed,
      std::ios_base::floatfield);
   os << std::numeric_limits<double>::max();
   std::string osstr(os.str());
   return osstr == "0x1.fffffffffffffp+1023";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
leaq -0x178(%rbp), %rdi
callq 0x8640
movq -0x178(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x178(%rbp,%rax), %rax
movq %rax, -0x1b8(%rbp)
movl $0x100, %edi            # imm = 0x100
movl $0x4, %esi
callq 0xd490
movl %eax, -0x1ac(%rbp)
jmp 0x8ed8
movl -0x1ac(%rbp), %esi
movq -0x1b8(%rbp), %rdi
movl $0x104, %edx            # imm = 0x104
callq 0xd430
jmp 0x8ef1
callq 0xd4b0
leaq -0x178(%rbp), %rdi
callq 0x88d0
jmp 0x8f04
leaq -0x1a8(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0x8460
jmp 0x8f19
leaq 0x6d5a0(%rip), %rsi     # 0x764c0
leaq -0x1a8(%rbp), %rdi
callq 0xd4c0
movb %al, -0x1b9(%rbp)
jmp 0x8f34
leaq -0x1a8(%rbp), %rdi
callq 0x8220
leaq -0x178(%rbp), %rdi
callq 0x80c0
movb -0x1b9(%rbp), %al
andb $0x1, %al
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
jmp 0x8f8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x180(%rbp)
movl %eax, -0x184(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x8220
leaq -0x178(%rbp), %rdi
callq 0x80c0
movq -0x180(%rbp), %rdi
callq 0x8800
nopw (%rax,%rax)
// File: afborchert[P]fmt/test_suite.cpp
// Function: bool testcase<char>(char const*)
bool testcase(const CharT* format, Values&&... values) {
   int offset = 0;
   return general_testcase(/* implementation defined = */ false,
      /* with offset = */ false, /* unused */ offset,
      /* to_string = */ false, /* string_len = */ 0,
      format, std::forward<Values>(values)...);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %r9
xorl %r8d, %r8d
leaq -0xc(%rbp), %rdx
movl %r8d, %edi
movl %r8d, %esi
movl %r8d, %ecx
callq 0x1a340
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: afborchert[P]fmt/test_suite.cpp
// Function: bool check_printf<char, float>(char const*, char const*, float&&)
bool check_printf(const CharT* expected, const CharT* format,
      Values&&... values) {
   int count = sprint(nullptr, 0, format, std::forward<Values>(values)...);
   bool ok = false;
   if (count >= 0) {
      CharT* buf = new CharT[count + 1];
      sprint(buf, count + 1, format, std::forward<Values>(values)...);
      ok = compare(expected, buf) == 0;
      if (!ok) {
	 fmt::printf(
	    "std::printf deviates from standard for \"%s\": \"%.*s\"\n",
	    format, count, buf);
      }
      delete[] buf;
   } else if (!ok) {
      fmt::printf("std::printf from standard for \"%s\"\n", format);
   }
   return ok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x3c170
movl %eax, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0xdce0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x8030
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x3c170
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8a60
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0xdcc7
leaq 0x693dc(%rip), %rdi     # 0x77092
leaq -0x10(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x3c1b0
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xdcde
movq -0x30(%rbp), %rdi
callq 0x85e0
jmp 0xdcf8
testb $0x1, -0x1d(%rbp)
jne 0xdcf6
leaq 0x693da(%rip), %rdi     # 0x770c7
leaq -0x10(%rbp), %rsi
callq 0x3c1f0
jmp 0xdcf8
movb -0x1d(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: afborchert[P]fmt/test_suite.cpp
// Function: bool implementation_dependent_testcase<char, char const*&>(char const*, char const*&)
bool implementation_dependent_testcase(const CharT* format,
      Values&&... values) {
   int offset = 0;
   return general_testcase(/* implementation defined = */ true,
      /* with offset = */ false, /* unused */ offset,
      /* to_string = */ false, /* string_len = */ 0,
      format, std::forward<Values>(values)...);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %r9
movq -0x10(%rbp), %rax
movl $0x1, %edi
xorl %r8d, %r8d
leaq -0x14(%rbp), %rdx
movl %r8d, %esi
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x41210
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: afborchert[P]fmt/test_suite.cpp
// Function: bool testcase_with_offset<char, int*>(int&, char const*, int*&&)
bool testcase_with_offset(int& offset,
      const CharT* format, Values&&... values) {
   return general_testcase(/* implementation defined = */ false,
      /* with offset = */ true, offset,
      /* to_string = */ false, /* string_len = */ 0,
      format, std::forward<Values>(values)...);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %r9
movq -0x18(%rbp), %rax
xorl %r8d, %r8d
movl $0x1, %esi
movl %r8d, %edi
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x57d50
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: afborchert[P]fmt/test_suite.cpp
// Function: bool testcase_for_snprintf<char, char (&) [14]>(int, char const*, char (&) [14])
bool testcase_for_snprintf(int string_len,
      const CharT* format, Values&&... values) {
   int offset = 0;
   return general_testcase(/* implementation defined = */ false,
      /* with offset = */ false, /* unused */ offset,
      /* to_string = */ true, /* string_len = */ string_len,
      format, std::forward<Values>(values)...);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x4(%rbp), %r8d
movq -0x10(%rbp), %r9
movq -0x18(%rbp), %rax
xorl %esi, %esi
leaq -0x1c(%rbp), %rdx
movl $0x1, %ecx
movl %esi, %edi
movq %rax, (%rsp)
callq 0x74440
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: afborchert[P]fmt/./printf.hpp
// Function: long fmt::impl::set_value<std::tuple<char const*&>>(std::tuple<char const*&> const&, long, long)
inline integer set_value(const Tuple& tuple, integer index,
      std::streamsize offset) {
   if (index >= 0 &&
	 index < static_cast<integer>(std::tuple_size<Tuple>::value)) {
      return apply(tuple, index, set_value_f(offset));
   } else {
      return -1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x10e06
cmpq $0x1, -0x18(%rbp)
jge 0x10e06
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x11aa0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x11a70
movq %rax, -0x8(%rbp)
jmp 0x10e0e
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: afborchert[P]fmt/./printf.hpp
// Function: long fmt::impl::get_value<std::tuple<char const*&>>(std::tuple<char const*&> const&, long)
inline integer get_value(const Tuple& tuple, integer index) {
   if (index >= 0 &&
	 index < static_cast<integer>(std::tuple_size<Tuple>::value)) {
      return apply(tuple, index, get_value_f());
   } else {
      return -1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x10e75
cmpq $0x1, -0x18(%rbp)
jge 0x10e75
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x19(%rbp), %rdx
callq 0x11c00
movq %rax, -0x8(%rbp)
jmp 0x10e7d
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: afborchert[P]fmt/./printf.hpp
// Function: bool fmt::impl::process_value<std::tuple<char const*&>, char, std::char_traits<char>>(std::tuple<char const*&> const&, long, std::basic_ostream<char, std::char_traits<char>>&, fmt::impl::format_segment<char> const&)
inline bool process_value(const Tuple& tuple, integer index,
      std::basic_ostream<CharT, Traits>& out,
      const format_segment<CharT>& fseg) {
   if (index >= 0 &&
	 index < static_cast<integer>(std::tuple_size<Tuple>::value)) {
      return apply(tuple, index, process_value_f<CharT, Traits>(out, fseg));
   } else {
      return false;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x1112f
cmpq $0x1, -0x18(%rbp)
jge 0x1112f
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x11dc0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x11d90
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11133
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: afborchert[P]fmt/./printf.hpp
// Function: fmt::impl::counting_ostreambuf<char, std::char_traits<char>>::overflow(int)
virtual int_type overflow(int_type ch) {
	 /* modeled after
	    https://stackoverflow.com/questions/10921761/extending-c-ostream */
	 if (ch == traits_type::eof()) {
	    return traits_type::eof();
	 } else {
	    char_type c = traits_type::to_char_type(ch);
	    return xsputn(&c, 1) == 1? ch: traits_type::eof();
	 }
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x113d0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jne 0x11385
callq 0x113d0
movl %eax, -0x4(%rbp)
jmp 0x113c0
leaq -0x14(%rbp), %rdi
callq 0x113e0
movq -0x28(%rbp), %rdi
movb %al, -0x15(%rbp)
movq (%rdi), %rax
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq *0x60(%rax)
cmpq $0x1, %rax
jne 0x113b2
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x113ba
callq 0x113d0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)