LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
testl %esi, 0x50(%rdi)
jne 0x4e78
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, 0x30(%rdi)
movups 0x58(%rdi), %xmm0
movups %xmm0, 0x38(%rdi)
movl 0x68(%rdi), %eax
movl %eax, 0x48(%rdi)
movl 0x54(%rdi), %eax
movl %eax, 0x4c(%rdi)
pushq $0x20
popq %rdi
callq 0x40c0
movups 0x30(%rbx), %xmm0
movups 0x40(%rbx), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
leaq 0x7e9a(%rip), %rsi      # 0xcd50
movq %rax, %rdi
xorl %edx, %edx
callq 0x42a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
movq %rcx, %rdx
movl %r8d, %ecx
callq 0x4c16
testq %rax, %rax
je 0x4f56
leaq 0x4185(%rip), %rsi      # 0x90b9
xorl %r15d, %r15d
leaq -0x20(%rbp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4160
cmpl $0x1, %eax
jne 0x4f5c
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%r14)
jmp 0x4f6b
pushq $0x4
popq %r15
jmp 0x4f6b
pushq $0x8
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x4e72
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %rsi
movq %r8, %rdx
movl %r9d, %ecx
callq 0x4c16
testq %rax, %rax
je 0x4fcb
movq %rax, %r12
leaq 0x4108(%rip), %rsi      # 0x90b6
xorl %r13d, %r13d
leaq -0x2c(%rbp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4160
cmpl $0x1, %eax
jne 0x4fd1
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
jmp 0x5009
pushq $0x4
popq %r13
jmp 0x5009
addq $0x8, %r15
movq -0x8(%r15), %rsi
testq %rsi, %rsi
je 0x4ff0
movq %r12, %rdi
callq 0x41b0
testl %eax, %eax
je 0x5001
addq $0x10, %r15
jmp 0x4fd5
pushq $0x8
popq %r13
movq %r14, %rdi
movl %r13d, %esi
callq 0x4e72
jmp 0x5009
movl (%r15), %eax
movl %eax, (%rbx)
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %rsi
movq %r8, %rdx
movl %r9d, %ecx
callq 0x4c16
testq %rax, %rax
je 0x5071
movq %rax, %r12
leaq 0x4069(%rip), %rsi      # 0x90b9
xorl %r13d, %r13d
leaq -0x30(%rbp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4160
cmpl $0x1, %eax
jne 0x5077
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rbx)
jmp 0x50b3
pushq $0x4
popq %r13
jmp 0x50b3
addq $0x8, %r15
movq -0x8(%r15), %rsi
testq %rsi, %rsi
je 0x5096
movq %r12, %rdi
callq 0x41b0
testl %eax, %eax
je 0x50a7
addq $0x10, %r15
jmp 0x507b
pushq $0x8
popq %r13
movq %r14, %rdi
movl %r13d, %esi
callq 0x4e72
jmp 0x50b3
movsd (%r15), %xmm0
movsd %xmm0, (%rbx)
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
jne 0x50dc
pushq $0x1
popq %rsi
callq 0x4e72
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x90e3(%rip), %r13      # 0xe1e1
movq 0x7edb(%rip), %rcx      # 0xcfe0
leaq 0x404f(%rip), %rbx      # 0x915b
pushq $0x38
popq %r14
pushq $0x1
popq %r15
movb -0x1(%r13), %r12b
testb %r12b, %r12b
je 0x5174
cmpb $0xd, %r12b
jne 0x5141
movzbl (%r13), %eax
cmpl $0xa, %eax
je 0x5131
testl %eax, %eax
jne 0x515f
cmpb $0x0, 0x91a9(%rip)      # 0xe2e1
je 0x5146
movb $0x1, 0x91a0(%rip)      # 0xe2e1
incq %r13
jmp 0x5114
movq %rcx, %r12
movq (%rcx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x42f0
movq %r12, %rcx
jmp 0x513a
movq (%rcx), %rcx
leaq 0x402b(%rip), %rdi      # 0x9194
pushq $0x39
popq %rsi
pushq $0x1
popq %rdx
callq 0x42f0
testb %r12b, %r12b
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rsi, %rax
movl (%rdi), %ecx
cmpq $0x8, %rcx
ja 0x5226
leaq 0x3e7c(%rip), %rdx      # 0x9090
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x3ea3(%rip), %rdx      # 0x90c7
jmp 0x525f
cmpl $0x10, %ecx
jne 0x5234
leaq 0x3ee2(%rip), %rdx      # 0x9114
jmp 0x525f
leaq 0x3ee4(%rip), %rdx      # 0x911f
jmp 0x525f
leaq 0x3ec1(%rip), %rdx      # 0x9105
jmp 0x525f
leaq 0x3e90(%rip), %rdx      # 0x90dd
jmp 0x525f
leaq 0x3e7a(%rip), %rdx      # 0x90d0
jmp 0x525f
leaq 0x3e94(%rip), %rdx      # 0x90f3
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x8(%rdi), %r8
movq 0x10(%rdi), %rcx
movl 0x18(%rdi), %r9d
movl 0x1c(%rdi), %esi
movl %esi, (%rsp)
leaq 0x3ea7(%rip), %rsi      # 0x9127
movq %rax, %rdi
xorl %eax, %eax
callq 0x4240
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
cmpq $0x0, 0x8fba(%rip)      # 0xe2f0
jne 0x5349
movq 0x7c79(%rip), %rax      # 0xcfb8
movq (%rax), %rax
movq %rax, 0x8fa7(%rip)      # 0xe2f0
leaq 0x7e80(%rip), %rdi      # 0xd1d0
leaq -0x110(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4260
xorl %ebx, %ebx
movabsq $0x800100000200, %rax   # imm = 0x800100000200
cmpq $0x100, %rbx            # imm = 0x100
je 0x540e
movzbl -0x110(%rbp,%rbx), %ecx
cmpq $0x2f, %rcx
ja 0x5393
btq %rcx, %rax
jae 0x5393
incq %rbx
jmp 0x536d
cmpl $0x4e, %ecx
je 0x539d
cmpl $0x6e, %ecx
jne 0x53f5
movq 0x8f4c(%rip), %rsi      # 0xe2f0
pushq $0x4e
popq %rdi
callq 0x4200
xorl %r14d, %r14d
cmpq $0xff, %rbx
jae 0x53ed
movzbl -0x10f(%rbp,%rbx), %edi
leal -0x30(%rdi), %eax
cmpb $0x9, %al
ja 0x53ed
movq 0x8f22(%rip), %rsi      # 0xe2f0
callq 0x4200
incl %r14d
incq %rbx
jmp 0x53af
movq 0x8f0e(%rip), %rsi      # 0xe2f0
pushq $0x20
popq %rdi
callq 0x4200
incl %r14d
cmpl $0x5, %r14d
jbe 0x53db
jmp 0x540e
movq 0x8ef4(%rip), %rcx      # 0xe2f0
leaq 0x3e0d(%rip), %rdi      # 0x9210
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x42f0
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8ec2(%rip), %rdi      # 0xe2f0
movl 0x7d78(%rip), %edx      # 0xd1ac
leal 0x1(%rdx), %eax
movl %eax, 0x7d6f(%rip)      # 0xd1ac
leaq 0x3dd4(%rip), %rsi      # 0x9218
xorl %eax, %eax
callq 0x4240
callq 0x5320
movq 0x8e99(%rip), %rdi      # 0xe2f0
leaq 0x3dbf(%rip), %rsi      # 0x921d
movsd -0x8(%rbp), %xmm0
movb $0x1, %al
addq $0x10, %rsp
popq %rbp
jmp 0x4240
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/saicanon.cc
// Function: SET_ORIGIN_OFFSETS(double, double, double, double, double, double, double, double, double)
void SET_ORIGIN_OFFSETS(
 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, "SET_ORIGIN_OFFSETS(%.4f, %.4f, %.4f"
         ", %.4f"  /*AA*/
         ", %.4f"  /*BB*/
         ", %.4f"  /*CC*/
         ")\n", x, y, z
         , a  /*AA*/
         , b  /*BB*/
         , c  /*CC*/
         );
  _program_position_x = _program_position_x + _program_origin_x - x;
  _program_position_y = _program_position_y + _program_origin_y - y;
  _program_position_z = _program_position_z + _program_origin_z - z;
  _program_position_a = _program_position_a + _program_origin_a - a;/*AA*/
  _program_position_b = _program_position_b + _program_origin_b - b;/*BB*/
  _program_position_c = _program_position_c + _program_origin_c - c;/*CC*/

  _program_origin_x = x;
  _program_origin_y = y;
  _program_origin_z = z;
  _program_origin_a = a;  /*AA*/
  _program_origin_b = b;  /*BB*/
  _program_origin_c = c;  /*CC*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm5, -0x30(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
movq 0x8e54(%rip), %rdi      # 0xe2f0
movl 0x7d0a(%rip), %edx      # 0xd1ac
leal 0x1(%rdx), %eax
movl %eax, 0x7d01(%rip)      # 0xd1ac
leaq 0x3d66(%rip), %rsi      # 0x9218
xorl %eax, %eax
callq 0x4240
callq 0x5320
movq 0x8e2b(%rip), %rdi      # 0xe2f0
leaq 0x3d68(%rip), %rsi      # 0x9234
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm3
movsd -0x28(%rbp), %xmm4
movsd -0x30(%rbp), %xmm5
movb $0x6, %al
callq 0x4240
movsd 0xa6f7(%rip), %xmm0     # 0xfbf0
addsd 0xa6f7(%rip), %xmm0     # 0xfbf8
movsd -0x8(%rbp), %xmm6
subsd %xmm6, %xmm0
movsd %xmm0, 0xa6de(%rip)     # 0xfbf0
movsd 0xa6e6(%rip), %xmm0     # 0xfc00
addsd 0xa6e6(%rip), %xmm0     # 0xfc08
movsd -0x10(%rbp), %xmm5
subsd %xmm5, %xmm0
movsd 0xa6dd(%rip), %xmm1     # 0xfc10
addsd 0xa6dd(%rip), %xmm1     # 0xfc18
movsd %xmm0, 0xa6bd(%rip)     # 0xfc00
movsd -0x18(%rbp), %xmm4
subsd %xmm4, %xmm1
movsd %xmm1, 0xa6bc(%rip)     # 0xfc10
movsd 0xa6c4(%rip), %xmm0     # 0xfc20
addsd 0xa6c4(%rip), %xmm0     # 0xfc28
movsd -0x20(%rbp), %xmm3
subsd %xmm3, %xmm0
movsd %xmm0, 0xa6ab(%rip)     # 0xfc20
movsd 0xa6b3(%rip), %xmm0     # 0xfc30
addsd 0xa6b3(%rip), %xmm0     # 0xfc38
movsd -0x28(%rbp), %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, 0xa69a(%rip)     # 0xfc30
movsd 0xa6a2(%rip), %xmm0     # 0xfc40
addsd 0xa6a2(%rip), %xmm0     # 0xfc48
movsd -0x30(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0xa689(%rip)     # 0xfc40
movsd %xmm6, 0xa639(%rip)     # 0xfbf8
movsd %xmm5, 0xa641(%rip)     # 0xfc08
movsd %xmm4, 0xa649(%rip)     # 0xfc18
movsd %xmm3, 0xa651(%rip)     # 0xfc28
movsd %xmm2, 0xa659(%rip)     # 0xfc38
movsd %xmm1, 0xa661(%rip)     # 0xfc48
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movsd %xmm5, -0x48(%rbp)
movsd %xmm4, -0x40(%rbp)
movsd %xmm3, -0x38(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x20(%rbp)
movq 0x89ca(%rip), %rdi      # 0xe2f0
movl 0x7880(%rip), %edx      # 0xd1ac
leal 0x1(%rdx), %eax
movl %eax, 0x7877(%rip)      # 0xd1ac
leaq 0x38dc(%rip), %rsi      # 0x9218
xorl %eax, %eax
callq 0x4240
callq 0x5320
movq 0x89a1(%rip), %rdi      # 0xe2f0
leaq 0x3992(%rip), %rsi      # 0x92e8
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm3
movsd -0x40(%rbp), %xmm4
movsd -0x48(%rbp), %xmm5
movb $0x6, %al
callq 0x4240
leaq 0x7846(%rip), %rax      # 0xd1c8
movl (%rax), %ebx
movsd -0x20(%rbp), %xmm0
subsd 0xa25f(%rip), %xmm0     # 0xfbf0
cvtsd2ss %xmm0, %xmm0
callq 0x4828
movl %eax, %r14d
movsd -0x28(%rbp), %xmm0
subsd 0xa256(%rip), %xmm0     # 0xfc00
cvtsd2ss %xmm0, %xmm0
callq 0x483a
movl %eax, %r15d
movsd -0x30(%rbp), %xmm0
subsd 0xa24d(%rip), %xmm0     # 0xfc10
cvtsd2ss %xmm0, %xmm0
callq 0x484c
movl %ebx, %edi
movl %r14d, %esi
movl %r15d, %edx
movl %eax, %ecx
callq 0x45df
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0xa208(%rip)     # 0xfbf0
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0xa20b(%rip)     # 0xfc00
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0xa20e(%rip)     # 0xfc10
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0xa211(%rip)     # 0xfc20
movsd -0x40(%rbp), %xmm0
movsd %xmm0, 0xa214(%rip)     # 0xfc30
movsd -0x48(%rbp), %xmm0
movsd %xmm0, 0xa217(%rip)     # 0xfc40
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x814c(%rip), %rdi      # 0xe2f0
movl 0x7002(%rip), %edx      # 0xd1ac
leal 0x1(%rdx), %eax
movl %eax, 0x6ff9(%rip)      # 0xd1ac
leaq 0x305e(%rip), %rsi      # 0x9218
xorl %eax, %eax
callq 0x4240
callq 0x5320
movq 0x8123(%rip), %rdi      # 0xe2f0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq 0x332c(%rip), %rsi      # 0x950f
movq %rax, %rdx
xorl %eax, %eax
callq 0x4240
movq 0x8(%rbx), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x99f3(%rip)     # 0xfbf0
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x99f6(%rip)     # 0xfc00
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testl %esi, %esi
sets %cl
orb %al, %cl
jne 0x7c63
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x66c0(%rip), %rdi      # 0xe300
callq 0x40a0
movl %r14d, %ecx
cmpq %rcx, %rax
jae 0x7c60
leaq 0x66ac(%rip), %rsi      # 0xe300
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4150
movb $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
leaq 0x20(%rsp), %rax
movq %rsi, (%rax)
movl %edx, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
leaq 0x33aab(%rip), %rdx     # 0x3a2cc
leaq 0x34890(%rip), %rcx     # 0x3b0b8
testl %edi, %edi
cmovneq %rdx, %rcx
movq %rcx, %rdi
movq %rax, %rsi
callq 0x9a22
cmpl %ebx, %ebp
jne 0x6861
leaq 0x33ab9(%rip), %rdi     # 0x3a2fd
leaq 0x18(%rsp), %rsi
callq 0x9a22
leaq 0x33abf(%rip), %rdi     # 0x3a314
leaq 0x10(%rsp), %rsi
callq 0x9a22
jmp 0x688d
leaq 0x33ac3(%rip), %rdi     # 0x3a32b
leaq 0x18(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x9a34
leaq 0x33ac9(%rip), %rdi     # 0x3a347
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x9a34
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
leaq 0x20(%rsp), %rax
movq %rsi, (%rax)
movl %edx, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
leaq 0x3488d(%rip), %rdx     # 0x3b14c
leaq 0x3494e(%rip), %rcx     # 0x3b214
testl %edi, %edi
cmovneq %rdx, %rcx
movq %rcx, %rdi
movq %rax, %rsi
callq 0x9a49
cmpl %ebx, %ebp
jne 0x68ff
leaq 0x3498e(%rip), %rdi     # 0x3b270
leaq 0x18(%rsp), %rsi
callq 0x9a49
leaq 0x349d9(%rip), %rdi     # 0x3b2cc
leaq 0x10(%rsp), %rsi
callq 0x9a49
jmp 0x692b
leaq 0x34a22(%rip), %rdi     # 0x3b328
leaq 0x18(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x9a5b
leaq 0x34a7c(%rip), %rdi     # 0x3b398
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x9a5b
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x6490
movq (%rbx), %rax
movq -0x18(%rax), %rax
orl $0x104, 0x38(%rsp,%rax) # imm = 0x104
movsd 0x3345a(%rip), %xmm0    # 0x3a008
movq %rbx, %rdi
callq 0x65c0
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x65a0
leaq 0x3387a(%rip), %rsi     # 0x3a444
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x9aca
movl %eax, %ebp
movq %rbx, %rdi
callq 0x61a0
leaq 0x20(%rsp), %rdi
callq 0x60b0
movl %ebp, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %rbp
retq
jmp 0x6bf7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x60b0
movq %rbx, %rdi
callq 0x6630
// File: /workspace/github_cpp_makefile_star2_O2/afborchert[P]fmt/test_suite.cpp
// Function: bool check_printf<char, int, int, int>(char const*, char const*, int&&, int&&, int&&)
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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq %rsi, 0x10(%rsp)
xorl %edi, %edi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x341d8
movl %eax, 0xc(%rsp)
testl %eax, %eax
js 0xa5cf
movl %eax, %ebx
incl %ebx
movq %rbx, %rdi
callq 0x6040
movq %rbp, 0x18(%rsp)
movq %rax, %rbp
movq %rax, 0x20(%rsp)
movq %rax, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x341d8
movq 0x18(%rsp), %rdi
movq %rbp, %rsi
callq 0x64d0
testl %eax, %eax
sete %bl
je 0xa5c5
leaq 0x30a68(%rip), %rdi     # 0x3b00e
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rcx
callq 0x1edee
movq (%r14), %rbp
testq %rbp, %rbp
je 0xa5e2
movq %rbp, %rdi
callq 0x6460
jmp 0xa5e2
leaq 0x30a6d(%rip), %rdi     # 0x3b043
leaq 0x10(%rsp), %rsi
callq 0x1ee06
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/afborchert[P]fmt/./printf.hpp
// Function: bool fmt::impl::parse_integer<char, long>(char const*&, long&)
bool parse_integer(const CharT*& format, T& val) {
   T v{};
   CharT ch = *format;
   constexpr T maxval = std::numeric_limits<T>::max();
   constexpr T maxval10 = maxval / 10;
   while (ch >= '0' && ch <= '9') {
      T digit = ch - '0';
      if (v > maxval10) return false;
      v *= 10;
      if (v > maxval - digit) return false;
      v += digit;
      ch = *++format;
   }
   val = v;
   return true;
}

// Assembly:
movq (%rdi), %rax
incq %rax
xorl %ecx, %ecx
movabsq $0xccccccccccccccc, %rdx # imm = 0xCCCCCCCCCCCCCCC
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
movzbl -0x1(%rax), %r9d
leal -0x3a(%r9), %r10d
cmpb $-0xa, %r10b
jb 0xbc03
cmpq %rdx, %rcx
jg 0xbc06
andl $0xf, %r9d
imulq $0xa, %rcx, %rcx
movq %r9, %r11
xorq %r8, %r11
cmpq %r11, %rcx
jg 0xbc06
addq %r9, %rcx
movq %rax, (%rdi)
incq %rax
jmp 0xbbd1
movq %rcx, (%rsi)
cmpb $-0xa, %r10b
setb %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/afborchert[P]fmt/./printf.hpp
// Function: long fmt::impl::count_digits<char>(char, long)
inline integer count_digits(Value value, integer base) {
   if (value == 0) {
      return 1;
   } else {
      integer digits = 0;
      while (value != 0) {
	 value /= base; ++digits;
      }
      return digits;
   }
}

// Assembly:
movl %edi, %eax
testb %al, %al
je 0x11257
xorl %ecx, %ecx
testb %al, %al
je 0x1125a
movsbq %al, %rax
cqto
idivq %rsi
incq %rcx
jmp 0x11245
pushq $0x1
popq %rcx
movq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/afborchert[P]fmt/./printf.hpp
// Function: int fmt::snprintf<>(char*, unsigned long, char const*)
inline int snprintf(char* s, std::size_t n,
      const char* format, Values&&... values) {
   std::ostringstream os;
   int nbytes = printf(os, format, std::forward<Values>(values)...);
   if (nbytes < 0) return nbytes;
   if (n == 0) return nbytes;
   std::string result(os.str());
   if (static_cast<std::size_t>(nbytes) + 1 <= n) {
      std::strcpy(s, result.c_str());
      return nbytes;
   } else {
      std::strcpy(s, result.substr(0, n-1).c_str());
      s[n-1] = 0;
      return n-1;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x6490
movq %r12, %rdi
movq %r15, %rsi
callq 0xfacd
movl %eax, %ebp
testl %eax, %eax
sets %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0xfa8b
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x65a0
movl %ebp, %eax
incl %eax
cmpq %r14, %rax
jbe 0xfa74
decq %r14
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x63c0
leaq 0x28(%rsp), %r15
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x6350
movq %r15, %rdi
callq 0x61a0
movb $0x0, (%rbx,%r14)
movl %r14d, %ebp
jmp 0xfa81
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6350
leaq 0x8(%rsp), %rdi
callq 0x61a0
leaq 0x48(%rsp), %rdi
callq 0x60b0
movl %ebp, %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x61a0
jmp 0xfabb
jmp 0xfab8
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x60b0
movq %rbx, %rdi
callq 0x6630
// File: /workspace/github_cpp_makefile_star2_O2/afborchert[P]fmt/./printf.hpp
// Function: int fmt::printf<char, std::char_traits<char>>(std::basic_ostream<char, std::char_traits<char>>&, char const*)
inline int printf(std::basic_ostream<CharT, Traits>& out,
      const CharT* format) {
   impl::counting_ostream<CharT, Traits> cout(out);

   while (format) {
      auto fseg = impl::parse_format_segment(format, 0);
      if (!fseg.valid) return -1;
      if (fseg.nof_args > 0) return -1;
      cout.write(fseg.beginp, fseg.endp - fseg.beginp);
      format = fseg.nextp;
   }
   return cout.get_count();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rsi, %r15
movq %rdi, %rsi
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xb210
leaq 0x8(%rsp), %r14
testq %r15, %r15
je 0xfb2e
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xb3ca
cmpb $0x1, 0x8(%rsp)
jne 0xfb37
cmpw $0x0, 0x38(%rsp)
jne 0xfb37
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x6470
movq 0x20(%rsp), %r15
jmp 0xfaf1
movl 0xc0(%rsp), %ebx
jmp 0xfb3a
pushq $-0x1
popq %rbx
leaq 0x70(%rsp), %rdi
callq 0xb98e
movl %ebx, %eax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xb98e
movq %rbx, %rdi
callq 0x6630
// File: /workspace/github_cpp_makefile_star2_O2/afborchert[P]fmt/./printf.hpp
// Function: fmt::impl::uppercase_ostreambuf<char, std::char_traits<char>>::xsputn(char const*, long)
virtual std::streamsize xsputn(const char_type* s,
	    std::streamsize count) {
	 for (std::streamsize i = 0; i < count; ++i) {
	    char_type ch = s[i];
	    if (std::islower(ch, this->getloc())) {
	       ch = std::toupper(ch, this->getloc());
	    }
	    if (sbuf.sputc(ch) == traits_type::eof()) {
	       return i;
	    }
	 }
	 return count;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
leaq 0x38(%rdi), %rax
movq %rax, (%rsp)
xorl %r15d, %r15d
testq %rdx, %rdx
movl $0x0, %r12d
movq %rdx, 0x10(%rsp)
cmovgq %rdx, %r12
leaq 0x8(%rsp), %r13
cmpq %r15, %r12
je 0x10eff
movq 0x20(%rsp), %rax
movb (%rax,%r15), %bpl
movq %r13, %rdi
movq (%rsp), %rsi
callq 0x6220
movsbl %bpl, %ebx
movl %ebx, %edi
movq %r13, %rsi
callq 0x10f62
movl %eax, %r14d
movq %r13, %rdi
callq 0x64f0
testb %r14b, %r14b
je 0x10ee0
movq %r13, %rdi
movq (%rsp), %rsi
callq 0x6220
movl %ebx, %edi
movq %r13, %rsi
callq 0x10f7e
movl %eax, %ebp
movq %r13, %rdi
callq 0x64f0
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rdi
movsbl %bpl, %esi
callq 0x6160
cmpl $-0x1, %eax
je 0x10efc
incq %r15
jmp 0x10e88
movq %r15, %r12
movq 0x10(%rsp), %rax
cmpq %rax, %r12
cmovlq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10f1c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x64f0
movq %rbx, %rdi
callq 0x6630
nop
// File: /workspace/github_cpp_makefile_star2_O2/afborchert[P]fmt/./printf.hpp
// Function: bool fmt::impl::print_value<char, std::char_traits<char>>(std::basic_ostream<char, std::char_traits<char>>&, fmt::impl::format_segment<char> const&, std::nullptr_t)
inline bool print_value(std::basic_ostream<CharT, Traits>& out,
      const format_segment<CharT>& fseg, std::nullptr_t value) {
   if (fseg.flags & is_pointer) {
      /* %p given: print pointer value */
      out << static_cast<const void*>(value);
      return !!out;
   } else if (fseg.flags & is_unsigned) {
      /* print it as an unsigned integer value */
      print_value(out, fseg, reinterpret_cast<std::uintptr_t>(value));
      return !!out;
   } else if (fseg.flags & is_integer) {
      /* print it as a signed integer value */
      print_value(out, fseg, reinterpret_cast<std::intptr_t>(value));
      return !!out;
   } else {
      /* fail otherwise */
      return false;
   }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movzwl 0x24(%rsi), %eax
testb $0x1, %al
jne 0x21cd3
testb $0x8, %al
jne 0x21cdf
testb $0x4, %al
jne 0x21cf2
xorl %eax, %eax
jmp 0x21d12
movq %rbx, %rdi
xorl %esi, %esi
callq 0x62a0
jmp 0x21d03
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
movq %rbx, %rdi
callq 0xbdca
jmp 0x21d03
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
movq %rbx, %rdi
callq 0xc019
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
sete %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/afborchert[P]fmt/./printf.hpp
// Function: std::enable_if<!is_char<TestObject<int>>::value, bool>::type fmt::impl::print_value<char, std::char_traits<char>, TestObject<int>>(std::basic_ostream<char, std::char_traits<char>>&, fmt::impl::format_segment<char> const&, TestObject<int> const*)
inline typename std::enable_if<!is_char<Value>::value, bool>::type
print_value(std::basic_ostream<CharT, Traits>& out,
      const format_segment<CharT>& fseg, const Value* value) {
   if (fseg.flags & is_pointer) {
      /* print the value of the pointer */
      out << static_cast<const void*>(value);
   } else if (fseg.flags & is_unsigned) {
      /* print it as an unsigned integer value */
      print_value(out, fseg, reinterpret_cast<std::uintptr_t>(value));
   } else if (fseg.flags & is_integer) {
      /* print it as a signed integer value */
      print_value(out, fseg, reinterpret_cast<std::intptr_t>(value));
   } else {
      out << value;
   }
   return !!out;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movzwl 0x24(%rsi), %eax
testb $0x1, %al
jne 0x38cb4
testb $0x8, %al
jne 0x38cc1
testb $0x4, %al
jne 0x38cd6
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x38cfe
jmp 0x38ce9
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x62a0
jmp 0x38ce9
leaq 0x8(%rsp), %rax
movq %rdx, (%rax)
movq %rbx, %rdi
movq %rax, %rdx
callq 0xbdca
jmp 0x38ce9
leaq 0x8(%rsp), %rax
movq %rdx, (%rax)
movq %rbx, %rdi
movq %rax, %rdx
callq 0xc019
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
sete %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/afborchert[P]fmt/./printf.hpp
// Function: int fmt::snprintf<>(wchar_t*, unsigned long, wchar_t const*)
inline int snprintf(wchar_t* s, std::size_t n,
      const wchar_t* format, Values&&... values) {
   std::wostringstream os;
   int nbytes = printf(os, format, std::forward<Values>(values)...);
   if (nbytes < 0) return nbytes;
   if (n == 0) return nbytes;
   std::wstring result(os.str());
   if (static_cast<std::size_t>(nbytes) + 1 <= n) {
      std::wcscpy(s, result.c_str());
      return nbytes;
   } else {
      std::wcscpy(s, result.substr(0, n-1).c_str());
      s[n] = 0;
      return n-1;
   }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0x62e0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2f27d
movl %eax, %ebx
testl %eax, %eax
sets %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x2f23e
leaq 0x48(%rsp), %rsi
movq %rsp, %rdi
callq 0x6100
movl %ebx, %eax
incl %eax
cmpq %r15, %rax
jbe 0x2f22a
leaq -0x1(%r15), %rbx
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x61e0
leaq 0x20(%rsp), %r12
movq (%r12), %rsi
movq %r14, %rdi
callq 0x6690
movq %r12, %rdi
callq 0x6090
andl $0x0, (%r14,%r15,4)
jmp 0x2f236
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x6690
movq %rsp, %rdi
callq 0x6090
leaq 0x40(%rsp), %rdi
callq 0x6520
movl %ebx, %eax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6090
jmp 0x2f26b
jmp 0x2f268
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x6520
movq %rbx, %rdi
callq 0x6630
// File: /workspace/github_cpp_makefile_star2_O2/afborchert[P]fmt/test_suite.cpp
// Function: int sprint<wchar_t&>(wchar_t*, unsigned long, wchar_t const*, wchar_t&)
int sprint(wchar_t* buffer, std::size_t size,
      const wchar_t* format, Values&&... values) {
   if (buffer && size > 0) {
      return std::swprintf(buffer, size, format,
	 std::forward<Values>(values)...);
   } else {
      /* unfortunately the behaviour of swprintf differs
	 from that of snprintf, i.e. if size == 0, just -1
	 is returned instead of computing the required buffer
	 size */
      wchar_t buf[1024]; // should be sufficient for our tests
      return std::swprintf(buf, sizeof buf/sizeof buf[0], format,
	 std::forward<Values>(values)...);
   }
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %r8b
orb %al, %r8b
jne 0x2fc61
movl (%rcx), %ecx
xorl %eax, %eax
jmp 0x6550
subq $0x1008, %rsp           # imm = 0x1008
movl (%rcx), %ecx
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
callq 0x6550
addq $0x1008, %rsp           # imm = 0x1008
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/ofxhome_main.cc
// Function: main
int main() {
  try {
    string dump = OfxHomeFullDumpString();
    cout << dump << endl;
    vector<Institution> insts = OfxDumpStringToInstitutions(dump);
    //for (const auto& i : insts) {
    //  cout << i << endl;
    //}
  } catch(const string& msg) {
    cout << msg << endl;
  }

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsp, %rdi
callq 0x8f34
movq 0x19b5a(%rip), %rdi     # 0x42f90
movq %rsp, %rsi
callq 0x61a0
movq %rax, %rdi
callq 0x6700
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x939a
leaq 0x20(%rsp), %rdi
callq 0xa0a0
movq %rsp, %rdi
callq 0x6890
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x29479
movq %rdx, %r14
movq %rax, %rbx
jmp 0x29487
movq %rdx, %r14
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6890
cmpl $0x1, %r14d
jne 0x294bb
movq %rbx, %rdi
callq 0x6070
movq 0x19af4(%rip), %rdi     # 0x42f90
movq %rax, %rsi
callq 0x61a0
movq %rax, %rdi
callq 0x6700
callq 0x6560
jmp 0x29465
movq %rax, %rbx
callq 0x6560
movq %rbx, %rdi
callq 0x6460
movq %rax, %rdi
callq 0x8386
// File: /workspace/github_cpp_makefile_star2_O2/micahcc[P]polygon_skeleton/./simple_svg.hpp
// Function: svg::Color::Color(svg::Color::Defaults)
Color(Defaults color)
            : transparent(false), red(0), green(0), blue(0)
        {
            switch (color)
            {
                case Aqua: assign(0, 255, 255); break;
                case Black: assign(0, 0, 0); break;
                case Blue: assign(0, 0, 255); break;
                case Brown: assign(165, 42, 42); break;
                case Cyan: assign(0, 255, 255); break;
                case Fuchsia: assign(255, 0, 255); break;
                case Green: assign(0, 128, 0); break;
                case Lime: assign(0, 255, 0); break;
                case Magenta: assign(255, 0, 255); break;
                case Orange: assign(255, 165, 0); break;
                case Purple: assign(128, 0, 128); break;
                case Red: assign(255, 0, 0); break;
                case Silver: assign(192, 192, 192); break;
                case White: assign(255, 255, 255); break;
                case Yellow: assign(255, 255, 0); break;
                default: transparent = true; break;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10021(%rip), %rax     # 0x13ab8
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
andq $0x0, 0xc(%rdi)
andl $0x0, 0x14(%rdi)
cmpl $0xe, %esi
ja 0x3b35
movl %esi, %eax
leaq 0x9587(%rip), %rcx      # 0xd040
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movabsq $0xff000000ff, %rax     # imm = 0xFF000000FF
jmp 0x3b54
movl $0xff, %eax
jmp 0x3b76
movabsq $0xff000000ff, %rax     # imm = 0xFF000000FF
jmp 0x3b18
movl $0xff, 0xc(%rdi)
andl $0x0, 0x14(%rdi)
jmp 0x3b85
movabsq $0xc0000000c0, %rax     # imm = 0xC0000000C0
movq %rax, 0xc(%rdi)
movl $0xc0, 0x14(%rdi)
jmp 0x3b85
movabsq $0xa5000000ff, %rax     # imm = 0xA5000000FF
movq %rax, 0xc(%rdi)
jmp 0x3b85
movabsq $0x2a000000a5, %rax     # imm = 0x2A000000A5
movq %rax, 0xc(%rdi)
movl $0x2a, 0x14(%rdi)
jmp 0x3b85
movb $0x1, 0x8(%rdi)
jmp 0x3b85
movl $0x80, 0x10(%rdi)
jmp 0x3b85
andl $0x0, 0x10(%rdi)
jmp 0x3b85
movabsq $0xff00000000, %rax     # imm = 0xFF00000000
movq %rax, 0x10(%rdi)
jmp 0x3b85
movabsq $0xff000000ff, %rax     # imm = 0xFF000000FF
movq %rax, 0xc(%rdi)
movl $0xff, 0x14(%rdi)
jmp 0x3b85
movl $0x80, %eax
movl %eax, 0xc(%rdi)
movl %eax, 0x14(%rdi)
jmp 0x3b85
movl $0xff, 0x10(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/micahcc[P]polygon_skeleton/./simple_svg.hpp
// Function: svg::Document::save() const
bool save() const
        {
            std::ofstream ofs(file_name.c_str());
            if (!ofs.good())
                return false;

            ofs << toString();
            ofs.close();
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rdi, %rbx
movq (%rdi), %rsi
leaq -0x230(%rbp), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x3220
movq (%r14), %rax
movq -0x18(%rax), %rax
movl -0x210(%rbp,%rax), %r14d
testl %r14d, %r14d
jne 0x3cf1
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x5098
leaq -0x230(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31d0
leaq -0x30(%rbp), %rdi
callq 0x30c0
leaq -0x230(%rbp), %rdi
callq 0x3290
testl %r14d, %r14d
sete %bl
leaq -0x230(%rbp), %rdi
callq 0x32b0
movl %ebx, %eax
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3d21
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x30c0
jmp 0x3d24
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x32b0
movq %rbx, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O2/micahcc[P]polygon_skeleton/./simple_svg.hpp
// Function: svg::Color::toString[abi:cxx11](svg::Layout const&) const
std::string toString(Layout const &) const
        {
            std::stringstream ss;
            if (transparent)
                ss << "transparent";
            else
                ss << "rgb(" << red << "," << green << "," << blue << ")";
            return ss.str();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x198(%rbp), %rdi
callq 0x3160
leaq -0x188(%rbp), %rdi
cmpb $0x0, 0x8(%r14)
je 0x3fab
leaq 0x90ec(%rip), %rsi      # 0xd095
jmp 0x4003
leaq 0x90ef(%rip), %rsi      # 0xd0a1
callq 0x31f0
movl 0xc(%r14), %esi
movq %rax, %rdi
callq 0x3350
leaq 0x90dc(%rip), %rsi      # 0xd0a6
movq %rax, %rdi
callq 0x31f0
movl 0x10(%r14), %esi
movq %rax, %rdi
callq 0x3350
leaq 0x90c1(%rip), %rsi      # 0xd0a6
movq %rax, %rdi
callq 0x31f0
movl 0x14(%r14), %esi
movq %rax, %rdi
callq 0x3350
movq %rax, %rdi
leaq 0x99f2(%rip), %rsi      # 0xd9f5
callq 0x31f0
leaq -0x180(%rbp), %rsi
movq %rbx, %rdi
callq 0x32f0
leaq -0x198(%rbp), %rdi
callq 0x3180
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x198(%rbp), %rdi
callq 0x3180
movq %rbx, %rdi
callq 0x3360
nop
// File: /workspace/github_cpp_makefile_star2_O2/micahcc[P]polygon_skeleton/voronoi.cpp
// Function: points_match(std::tuple<Vector const*, Vector const*, Vector const*>, std::tuple<Vector const*, Vector const*, Vector const*>)
bool points_match(std::tuple<const Point*, const Point*, const Point*> lhs,
        std::tuple<const Point*, const Point*, const Point*> rhs)
{
    return (std::get<0>(lhs) == std::get<0>(rhs) &&
            std::get<1>(lhs) == std::get<1>(rhs) &&
            std::get<2>(lhs) == std::get<2>(rhs)) ||
           (std::get<0>(lhs) == std::get<0>(rhs) &&
            std::get<1>(lhs) == std::get<2>(rhs) &&
            std::get<2>(lhs) == std::get<1>(rhs)) ||
           (std::get<0>(lhs) == std::get<1>(rhs) &&
            std::get<1>(lhs) == std::get<2>(rhs) &&
            std::get<2>(lhs) == std::get<0>(rhs)) ||
           (std::get<0>(lhs) == std::get<1>(rhs) &&
            std::get<1>(lhs) == std::get<0>(rhs) &&
            std::get<2>(lhs) == std::get<2>(rhs)) ||
           (std::get<0>(lhs) == std::get<2>(rhs) &&
            std::get<1>(lhs) == std::get<0>(rhs) &&
            std::get<2>(lhs) == std::get<1>(rhs)) ||
           (std::get<0>(lhs) == std::get<2>(rhs) &&
            std::get<1>(lhs) == std::get<1>(rhs) &&
            std::get<2>(lhs) == std::get<0>(rhs));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rdx
movq 0x10(%rsi), %rax
cmpq %rax, %rdx
je 0x59ea
movq (%rsi), %r8
movq 0x8(%rsi), %rcx
jmp 0x5a0e
movq 0x8(%rdi), %r8
movq (%rsi), %r9
movq 0x8(%rsi), %rcx
cmpq %rcx, %r8
jne 0x59ff
cmpq %r9, (%rdi)
je 0x5a47
cmpq %r9, %r8
je 0x5a09
movq %r9, %r8
jmp 0x5a0e
cmpq %rcx, (%rdi)
je 0x5a47
cmpq %rcx, %rdx
jne 0x5a2b
movq 0x8(%rdi), %rsi
cmpq %r8, %rsi
jne 0x5a21
cmpq %rax, (%rdi)
je 0x5a47
cmpq %rax, %rsi
jne 0x5a2b
cmpq %r8, (%rdi)
je 0x5a47
cmpq %r8, %rdx
jne 0x5a43
movq 0x8(%rdi), %rdx
cmpq %rax, %rdx
jne 0x5a3e
cmpq %rcx, (%rdi)
je 0x5a47
cmpq %rcx, %rdx
je 0x5a4b
xorl %eax, %eax
jmp 0x5a51
movb $0x1, %al
jmp 0x5a51
cmpq %rax, (%rdi)
sete %al
popq %rbp
retq