LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/driver.cc
// Function: report_error(int, int)
void report_error( /* ARGUMENTS                            */
 int error_code,   /* the code number of the error message */
 int print_stack)  /* print stack if ON, otherwise not     */
{
  char interp_error_text_buf[LINELEN];
  int k;

  error_text(error_code, interp_error_text_buf, 5); /* for coverage of code */
  error_text(error_code, interp_error_text_buf, LINELEN);
  fprintf(stderr, "%s\n",
          ((interp_error_text_buf[0] == 0) ? "Unknown error, bad error code" : interp_error_text_buf));
  line_text(interp_error_text_buf, LINELEN);
  fprintf(stderr, "%s\n", interp_error_text_buf);
  if (print_stack == ON)
    {
      for (k = 0; ; k++)
        {
          stack_name(k, interp_error_text_buf, LINELEN);
          if (interp_error_text_buf[0] != 0)
            fprintf(stderr, "%s\n", interp_error_text_buf);
          else
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %esi, %ebx
movl %edi, %r12d
leaq 0x8ea0(%rip), %r15      # 0xd1d0
leaq -0x130(%rbp), %r14
pushq $0x5
popq %rcx
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x4110
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
movl $0xff, %ecx
callq 0x4110
movq 0x8c7e(%rip), %r13      # 0xcfe0
cmpb $0x0, (%r14)
movq (%r13), %rdi
leaq 0x4c97(%rip), %rdx      # 0x9008
cmovneq %r14, %rdx
leaq 0x4c88(%rip), %r12      # 0x9004
movq %r12, %rsi
xorl %eax, %eax
callq 0x4240
movq %r15, %rdi
movq %r14, %rsi
movl $0xff, %edx
callq 0x4260
movq (%r13), %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4240
cmpl $0x1, %ebx
jne 0x4414
leaq 0x8e1d(%rip), %rdi      # 0xd1d0
leaq -0x130(%rbp), %rbx
xorl %esi, %esi
movq %rbx, %rdx
movl $0xff, %ecx
callq 0x41a0
cmpb $0x0, (%rbx)
je 0x4414
pushq $0x1
popq %rbx
leaq 0x4c2c(%rip), %r14      # 0x9004
leaq -0x130(%rbp), %r15
leaq 0x8dea(%rip), %r12      # 0xd1d0
movq (%r13), %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4240
movq %r12, %rdi
movl %ebx, %esi
movq %r15, %rdx
movl $0xff, %ecx
callq 0x41a0
incl %ebx
cmpb $0x0, -0x130(%rbp)
jne 0x43e6
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/driver.cc
// Function: spi_write_single(int, unsigned short, unsigned short)
static uint16_t spi_write_single(int fd,uint16_t addr,uint16_t dat)
{

	int ret;
	uint8_t tx_temp[4];
	uint8_t rx_temp[4];
	struct spi_ioc_transfer tr[2];

	tr[0].tx_buf = (unsigned long)tx_temp,
	tr[0].rx_buf = (unsigned long)rx_temp,
	tr[0].len = 2,
	tr[0].delay_usecs = 0,//delay,
	tr[0].speed_hz = SPI_SPEED,
	tr[0].bits_per_word = SPI_BITS,
	tr[0].cs_change = 0,
	tr[1].tx_buf = (unsigned long)&tx_temp[2],
	tr[1].rx_buf = (unsigned long)rx_temp,
	tr[1].len = 2,
	tr[1].delay_usecs = 0,//delay,
	tr[1].speed_hz = SPI_SPEED,
	tr[1].bits_per_word = SPI_BITS,
	tr[1].cs_change = 0,

	tx_temp[0] = (addr >> 8) | 0x80;
	tx_temp[1] = (addr & 0x00ff);
	tx_temp[2] = dat >> 8;
	tx_temp[3] = dat & 0x00ff;
	memset(rx_temp,0,4);
	ret = ioctl(fd, SPI_IOC_MESSAGE(2), &tr);
	if (ret < 1)
		pabort("can't send spi message");
	return 0;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edx, %eax
leaq -0x4(%rbp), %rcx
leaq -0x50(%rbp), %rdx
movq %rcx, (%rdx)
leaq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rdx)
movabsq $0xf424000000002, %r8   # imm = 0xF424000000002
movq %r8, 0x10(%rdx)
movl $0x80000, %r9d          # imm = 0x80000
movl %r9d, 0x18(%rdx)
leaq -0x2(%rbp), %r10
movq %r10, 0x20(%rdx)
movq %rcx, 0x28(%rdx)
movq %r8, 0x30(%rdx)
movl %r9d, 0x38(%rdx)
movl %esi, %r8d
shrl $0x8, %r8d
orb $-0x80, %r8b
movb %r8b, -0x2(%r10)
movb %sil, -0x1(%r10)
movb %ah, -0x2(%rbp)
movb %al, 0x1(%r10)
movl $0x0, (%rcx)
movl $0x40406b00, %esi       # imm = 0x40406B00
xorl %eax, %eax
callq 0x4230
testl %eax, %eax
jle 0x492f
addq $0x50, %rsp
popq %rbp
retq
callq 0x448b
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/driver.cc
// Function: fpga_spi_init()
int fpga_spi_init(void)
{
	int err = 0;
	static uint8_t mode = SPI_CPHA;

	spi_fd = open("/dev/spidev0.0",O_RDWR);
	if(spi_fd < 0)
		pabort("/dev/spidev0.0");
	err = ioctl(spi_fd, SPI_IOC_WR_MODE, &mode);
	if (err == -1)
		pabort("set spi mode");
	return spi_fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x46c7(%rip), %rdi      # 0x903c
movl $0x2, %esi
xorl %eax, %eax
callq 0x4120
movl %eax, 0x8841(%rip)      # 0xd1c8
testl %eax, %eax
js 0x49ad
leaq 0x880a(%rip), %rdx      # 0xd19c
movl $0x40016b01, %esi       # imm = 0x40016B01
movl %eax, %edi
xorl %eax, %eax
callq 0x4230
cmpl $-0x1, %eax
je 0x49b2
movl 0x881d(%rip), %eax      # 0xd1c8
popq %rbp
retq
callq 0x44b5
callq 0x44a0
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/driver.cc
// Function: main
int main (int argc, char ** argv)
{
	int status;
	int block_delete = OFF;
	int print_stack = OFF;
	char line[LINELEN];

	if (read_tool_file(TOOL_CONFIGURE_PATH) != 0)
		exit(1);

	if ((status = interp_init()) != INTERP_OK)
	{
		report_error(status, print_stack);
		exit(1);
	}
	spi_fd = fpga_spi_init();
	for(; ;)
	{
		char *result;
		printf("READ => ");
		memset(line, 0, sizeof(line));
		result = fgets(line, LINELEN, stdin);
		if (!result || strcmp (line, "quit\n") == 0)
			return 0;
		interpret_one_line(block_delete, print_stack, line);
	}
	close(spi_fd);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq 0x468e(%rip), %rdi      # 0x9058
callq 0x4691
testl %eax, %eax
jne 0x4a57
leaq 0x87f2(%rip), %rdi      # 0xd1d0
callq 0x42b0
testl %eax, %eax
jne 0x4a61
callq 0x496a
movl %eax, 0x87d6(%rip)      # 0xd1c8
leaq 0x466e(%rip), %rdi      # 0x9067
xorl %eax, %eax
callq 0x4030
leaq -0x110(%rbp), %rbx
movl $0xff, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x40e0
movq 0x85b3(%rip), %rax      # 0xcfd0
movq (%rax), %rdx
movq %rbx, %rdi
movl $0xff, %esi
callq 0x4280
testq %rax, %rax
je 0x4a4b
movl $0x74697571, %eax       # imm = 0x74697571
xorl -0x110(%rbp), %eax
movzwl -0x10c(%rbp), %ecx
xorl $0xa, %ecx
orl %eax, %ecx
jne 0x4a68
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %rbp
retq
movl $0x1, %edi
callq 0x41e0
movl %eax, %edi
callq 0x44ca
leaq -0x110(%rbp), %rdx
xorl %edi, %edi
xorl %esi, %esi
callq 0x465c
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/inifile.cc
// Function: IniFile::IniFile(int, _IO_FILE*)
IniFile::IniFile(int _errMask, FILE *_fp)
{
    fp = _fp;
    errMask = _errMask;
    owned = false;

    if(fp != NULL)
        LockFile();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdx, (%rdi)
movl %esi, 0x50(%rdi)
movb $0x0, 0x28(%rdi)
testq %rdx, %rdx
je 0x4a91
popq %rbp
jmp 0x4a94
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/inifile.cc
// Function: IniFile::LockFile()
bool
IniFile::LockFile(void)
{
    lock.l_type = F_RDLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start = 0;
    lock.l_len = 0;

    if(fcntl(fileno(fp), F_SETLK, &lock) == -1){
        if(owned)
            fclose(fp);

        fp = NULL;
        return(false);
    }

    return(true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movl $0x0, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq (%rdi), %rdi
callq 0x4190
movl %eax, %edi
movl $0x6, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4100
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0x4ae6
cmpb $0x1, 0x28(%rbx)
jne 0x4adf
movq (%rbx), %rdi
callq 0x4180
movq $0x0, (%rbx)
cmpl $-0x1, %r14d
setne %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/inifile.cc
// Function: IniFile::Open(char const*)
bool
IniFile::Open(const char *file)
{
    char                        path[LINELEN] = "";

    if(IsOpen()) Close();

    TildeExpansion(file, path);

    if((fp = fopen(path, "r")) == NULL)
        return(false);

    owned = true;

    if(!LockFile())
        return(false);

    return(true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x120(%rbp), %rdi
movl $0xff, %edx
xorl %esi, %esi
callq 0x40e0
cmpq $0x0, (%rbx)
je 0x4b29
movq %rbx, %rdi
callq 0x4b70
leaq -0x120(%rbp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x4bc8
leaq 0x4572(%rip), %rsi      # 0x90b4
movq %r15, %rdi
callq 0x41c0
movq %rax, (%rbx)
testq %rax, %rax
je 0x4b60
movb $0x1, 0x28(%rbx)
movq %rbx, %rdi
callq 0x4a94
jmp 0x4b62
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/inifile.cc
// Function: IniFile::Close()
bool
IniFile::Close()
{
    int                         rVal = 0;

    if(fp != NULL){
        lock.l_type = F_UNLCK;
        fcntl(fileno(fp), F_SETLKW, &lock);

        if(owned)
            rVal = fclose(fp);

        fp = NULL;
    }

    return(rVal == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4bc0
leaq 0x8(%rbx), %r14
movw $0x2, 0x8(%rbx)
callq 0x4190
movl %eax, %edi
movl $0x7, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4100
movb $0x1, %al
cmpb $0x1, 0x28(%rbx)
jne 0x4bb7
movq (%rbx), %rdi
callq 0x4180
testl %eax, %eax
sete %al
movq $0x0, (%rbx)
jmp 0x4bc2
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl $0xff, %edx
movq %r14, %rdi
callq 0x40d0
movq %rbx, %rdi
callq 0x40a0
cmpq $0x2, %rax
jb 0x4c29
cmpb $0x7e, (%rbx)
jne 0x4c29
cmpb $0x2f, 0x1(%rbx)
jne 0x4c29
movq %rax, %r15
leaq 0x44b9(%rip), %rdi      # 0x90c2
callq 0x41f0
testq %rax, %rax
je 0x4c29
movq %rax, %r12
movq %rax, %rdi
callq 0x40a0
addq %r15, %rax
cmpq $0xff, %rax
jbe 0x4c32
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
incq %rbx
movq %r14, %rdi
movq %r12, %rsi
callq 0x4160
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x42d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rax
movl %ecx, %r15d
movl %edx, %r14d
movq %rsi, %rbx
movl 0x10(%rbp), %r8d
leaq -0x1c(%rbp), %rsi
movq %rax, %rdx
movq %r9, %rcx
callq 0x4ca8
testl %eax, %eax
jne 0x4c9d
movl -0x1c(%rbp), %ecx
cmpl %r15d, %ecx
setg %al
cmpl %r14d, %ecx
setl %dl
orb %al, %dl
movl $0x10, %eax
jne 0x4c9d
movl %ecx, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
movq %rcx, %rdx
movl %r8d, %ecx
callq 0x4d1a
testq %rax, %rax
je 0x4cf0
leaq 0x43e4(%rip), %rsi      # 0x90b6
xorl %r15d, %r15d
leaq -0x1c(%rbp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4170
cmpl $0x1, %eax
jne 0x4cf8
movl -0x1c(%rbp), %eax
movl %eax, (%r14)
jmp 0x4d0b
movl $0x4, %r15d
jmp 0x4d0b
movl $0x8, %r15d
movq %rbx, %rdi
movl $0x8, %esi
callq 0x507c
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5082
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)
movl $0x20, %edi
callq 0x40c0
movups 0x30(%rbx), %xmm0
movups 0x40(%rbx), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
leaq 0x7c8e(%rip), %rsi      # 0xcd50
movq %rax, %rdi
xorl %edx, %edx
callq 0x42a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d1a
testq %rax, %rax
je 0x5164
leaq 0x3f77(%rip), %rsi      # 0x90b9
xorl %r15d, %r15d
leaq -0x20(%rbp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4170
cmpl $0x1, %eax
jne 0x516c
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%r14)
jmp 0x517f
movl $0x4, %r15d
jmp 0x517f
movl $0x8, %r15d
movq %rbx, %rdi
movl $0x8, %esi
callq 0x507c
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d1a
testq %rax, %rax
je 0x51df
movq %rax, %r12
leaq 0x3ef4(%rip), %rsi      # 0x90b6
xorl %r13d, %r13d
leaq -0x2c(%rbp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4170
cmpl $0x1, %eax
jne 0x51e7
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
jmp 0x5229
movl $0x4, %r13d
jmp 0x5229
movq (%r15), %rsi
testq %rsi, %rsi
je 0x520b
addq $0x10, %r15
movq %r12, %rdi
callq 0x41b0
testl %eax, %eax
je 0x5220
movq (%r15), %rsi
addq $0x10, %r15
testq %rsi, %rsi
jne 0x51f3
movl $0x8, %r13d
movq %r14, %rdi
movl $0x8, %esi
callq 0x507c
jmp 0x5229
movl -0x8(%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_O1/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 0x4d1a
testq %rax, %rax
je 0x5291
movq %rax, %r12
leaq 0x3e49(%rip), %rsi      # 0x90b9
xorl %r13d, %r13d
leaq -0x30(%rbp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x4170
cmpl $0x1, %eax
jne 0x5299
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rbx)
jmp 0x52df
movl $0x4, %r13d
jmp 0x52df
movq (%r15), %rsi
testq %rsi, %rsi
je 0x52bd
addq $0x10, %r15
movq %r12, %rdi
callq 0x41b0
testl %eax, %eax
je 0x52d2
movq (%r15), %rsi
addq $0x10, %r15
testq %rsi, %rsi
jne 0x52a5
movl $0x8, %r13d
movq %r14, %rdi
movl $0x8, %esi
callq 0x507c
jmp 0x52df
movsd -0x8(%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_O1/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 0x530a
movl $0x1, %esi
callq 0x507c
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movb 0x8ebc(%rip), %al       # 0xe1e0
testb %al, %al
setne %bl
je 0x536e
leaq 0x8eaf(%rip), %r14      # 0xe1e1
cmpb $0xd, %al
jne 0x5353
movzbl (%r14), %eax
cmpl $0xa, %eax
je 0x5343
testl %eax, %eax
jne 0x5369
cmpb $0x0, 0x8f97(%rip)      # 0xe2e1
je 0x5362
movb $0x1, 0x8f8e(%rip)      # 0xe2e1
movb (%r14), %al
incq %r14
testb %al, %al
setne %bl
jne 0x5332
jmp 0x536e
callq 0x44dd
jmp 0x534c
callq 0x450c
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5414
leaq 0x3c8e(%rip), %rdx      # 0x9090
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x3cb5(%rip), %rdx      # 0x90c7
jmp 0x544d
cmpl $0x10, %ecx
jne 0x5422
leaq 0x3cf4(%rip), %rdx      # 0x9114
jmp 0x544d
leaq 0x3cf6(%rip), %rdx      # 0x911f
jmp 0x544d
leaq 0x3cd3(%rip), %rdx      # 0x9105
jmp 0x544d
leaq 0x3ca2(%rip), %rdx      # 0x90dd
jmp 0x544d
leaq 0x3c8c(%rip), %rdx      # 0x90d0
jmp 0x544d
leaq 0x3ca6(%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 0x3cb9(%rip), %rsi      # 0x9127
movq %rax, %rdi
xorl %eax, %eax
callq 0x4240
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
cmpq $0x0, 0x8dd4(%rip)      # 0xe2f0
jne 0x552f
movq 0x7a93(%rip), %rax      # 0xcfb8
movq (%rax), %rax
movq %rax, 0x8dc1(%rip)      # 0xe2f0
leaq 0x7c9a(%rip), %rdi      # 0xd1d0
leaq -0x120(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4260
xorl %ebx, %ebx
movabsq $0x800100000200, %rax   # imm = 0x800100000200
movzbl -0x120(%rbp,%rbx), %ecx
cmpq $0x2f, %rcx
ja 0x5578
btq %rcx, %rax
jae 0x5578
incq %rbx
cmpq $0x100, %rbx            # imm = 0x100
jne 0x5553
jmp 0x5624
cmpl $0x4e, %ecx
je 0x5582
cmpl $0x6e, %ecx
jne 0x55e2
movq 0x8d67(%rip), %rsi      # 0xe2f0
movl $0x4e, %edi
callq 0x4200
xorl %r14d, %r14d
cmpq $0xfe, %rbx
ja 0x5604
movl $0xff, %r14d
subq %rbx, %r14
xorl %r15d, %r15d
leaq (%r15,%rbp), %rax
addq $-0x120, %rax           # imm = 0xFEE0
movzbl 0x1(%rbx,%rax), %edi
leal -0x30(%rdi), %eax
cmpb $0x9, %al
ja 0x5601
movq 0x8d28(%rip), %rsi      # 0xe2f0
callq 0x4200
leaq 0x1(%r15), %rax
addl %ebx, %r15d
cmpl $0xfe, %r15d
movq %rax, %r15
jne 0x55ab
jmp 0x5604
movq 0x8d07(%rip), %rcx      # 0xe2f0
leaq 0x3c28(%rip), %rdi      # 0x9218
movl $0x7, %esi
movl $0x1, %edx
callq 0x42f0
jmp 0x5624
movl %r15d, %r14d
cmpl $0x5, %r14d
ja 0x5624
addl $-0x6, %r14d
movq 0x8cdb(%rip), %rsi      # 0xe2f0
movl $0x20, %edi
callq 0x4200
incl %r14d
jne 0x560e
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8caa(%rip), %rdi      # 0xe2f0
movl 0x7b60(%rip), %edx      # 0xd1ac
leal 0x1(%rdx), %eax
movl %eax, 0x7b57(%rip)      # 0xd1ac
leaq 0x3bc4(%rip), %rsi      # 0x9220
xorl %eax, %eax
callq 0x4240
callq 0x5504
movq 0x8c81(%rip), %rdi      # 0xe2f0
leaq 0x3baf(%rip), %rsi      # 0x9225
movsd -0x8(%rbp), %xmm0
movb $0x1, %al
addq $0x10, %rsp
popq %rbp
jmp 0x4240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8c3c(%rip), %rdi      # 0xe2f0
movl 0x7af2(%rip), %edx      # 0xd1ac
leal 0x1(%rdx), %eax
movl %eax, 0x7ae9(%rip)      # 0xd1ac
leaq 0x3b56(%rip), %rsi      # 0x9220
xorl %eax, %eax
callq 0x4240
callq 0x5504
movq 0x8c13(%rip), %rdi      # 0xe2f0
leaq 0x3b58(%rip), %rsi      # 0x923c
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 0xa4df(%rip), %xmm0     # 0xfbf0
addsd 0xa4df(%rip), %xmm0     # 0xfbf8
movsd -0x8(%rbp), %xmm6
subsd %xmm6, %xmm0
movsd %xmm0, 0xa4c6(%rip)     # 0xfbf0
movsd 0xa4ce(%rip), %xmm0     # 0xfc00
addsd 0xa4ce(%rip), %xmm0     # 0xfc08
movsd -0x10(%rbp), %xmm5
subsd %xmm5, %xmm0
movsd 0xa4c5(%rip), %xmm1     # 0xfc10
addsd 0xa4c5(%rip), %xmm1     # 0xfc18
movsd %xmm0, 0xa4a5(%rip)     # 0xfc00
movsd -0x18(%rbp), %xmm4
subsd %xmm4, %xmm1
movsd %xmm1, 0xa4a4(%rip)     # 0xfc10
movsd 0xa4ac(%rip), %xmm0     # 0xfc20
addsd 0xa4ac(%rip), %xmm0     # 0xfc28
movsd -0x20(%rbp), %xmm3
subsd %xmm3, %xmm0
movsd %xmm0, 0xa493(%rip)     # 0xfc20
movsd 0xa49b(%rip), %xmm0     # 0xfc30
addsd 0xa49b(%rip), %xmm0     # 0xfc38
movsd -0x28(%rbp), %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, 0xa482(%rip)     # 0xfc30
movsd 0xa48a(%rip), %xmm0     # 0xfc40
addsd 0xa48a(%rip), %xmm0     # 0xfc48
movsd -0x30(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0xa471(%rip)     # 0xfc40
movsd %xmm6, 0xa421(%rip)     # 0xfbf8
movsd %xmm5, 0xa429(%rip)     # 0xfc08
movsd %xmm4, 0xa431(%rip)     # 0xfc18
movsd %xmm3, 0xa439(%rip)     # 0xfc28
movsd %xmm2, 0xa441(%rip)     # 0xfc38
movsd %xmm1, 0xa449(%rip)     # 0xfc48
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x877a(%rip), %rdi      # 0xe2f0
movl 0x7630(%rip), %edx      # 0xd1ac
leal 0x1(%rdx), %eax
movl %eax, 0x7627(%rip)      # 0xd1ac
leaq 0x3694(%rip), %rsi      # 0x9220
xorl %eax, %eax
callq 0x4240
callq 0x5504
movq 0x8751(%rip), %rdi      # 0xe2f0
leaq 0x374a(%rip), %rsi      # 0x92f0
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 0x75f6(%rip), %rax      # 0xd1c8
movl (%rax), %ebx
movsd -0x20(%rbp), %xmm0
subsd 0xa00f(%rip), %xmm0     # 0xfbf0
cvtsd2ss %xmm0, %xmm0
callq 0x4934
movl %eax, %r14d
movsd -0x28(%rbp), %xmm0
subsd 0xa006(%rip), %xmm0     # 0xfc00
cvtsd2ss %xmm0, %xmm0
callq 0x4946
movl %eax, %r15d
movsd -0x30(%rbp), %xmm0
subsd 0x9ffd(%rip), %xmm0     # 0xfc10
cvtsd2ss %xmm0, %xmm0
callq 0x4958
movl %ebx, %edi
movl %r14d, %esi
movl %r15d, %edx
movl %eax, %ecx
callq 0x46d6
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x9fb8(%rip)     # 0xfbf0
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x9fbb(%rip)     # 0xfc00
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x9fbe(%rip)     # 0xfc10
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x9fc1(%rip)     # 0xfc20
movsd -0x40(%rbp), %xmm0
movsd %xmm0, 0x9fc4(%rip)     # 0xfc30
movsd -0x48(%rbp), %xmm0
movsd %xmm0, 0x9fc7(%rip)     # 0xfc40
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7e55(%rip), %rdi      # 0xe2f0
movl 0x6d0b(%rip), %edx      # 0xd1ac
leal 0x1(%rdx), %eax
movl %eax, 0x6d02(%rip)      # 0xd1ac
leaq 0x2d6f(%rip), %rsi      # 0x9220
xorl %eax, %eax
callq 0x4240
callq 0x5504
movq 0x8(%rbx), %rax
subq (%rbx), %rax
movq 0x7e25(%rip), %rdi      # 0xe2f0
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
leaq 0x3033(%rip), %rsi      # 0x9517
xorl %eax, %eax
callq 0x4240
movq 0x8(%rbx), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x96f5(%rip)     # 0xfbf0
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x96f8(%rip)     # 0xfc00
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8166
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x61bd(%rip), %rdi      # 0xe300
callq 0x40a0
movl %r14d, %ecx
cmpq %rcx, %rax
jae 0x8163
leaq 0x61a9(%rip), %rsi      # 0xe300
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4160
movb $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x20, %rsp
leaq 0x18(%rsp), %rax
movq %rsi, (%rax)
movl %edx, 0x4(%rsp)
movl %ecx, (%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
leaq 0x3db21(%rip), %rcx     # 0x4427c
leaq 0x3e906(%rip), %rsi     # 0x45068
testl %edi, %edi
cmovneq %rcx, %rsi
movq 0x4d861(%rip), %rdi     # 0x53fd0
movq %rax, %rdx
callq 0xcfa8
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jne 0x67b1
movq 0x4d849(%rip), %rbx     # 0x53fd0
leaq 0x3db1f(%rip), %rsi     # 0x442ad
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xcfa8
leaq 0x3db22(%rip), %rsi     # 0x442c4
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xcfa8
jmp 0x67e8
movq 0x4d818(%rip), %rbx     # 0x53fd0
leaq 0x3db1c(%rip), %rsi     # 0x442db
leaq 0x10(%rsp), %rdx
leaq 0x4(%rsp), %rcx
movq %rbx, %rdi
callq 0xe779
leaq 0x3db1f(%rip), %rsi     # 0x442f7
leaq 0x8(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0xe779
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x20, %rsp
leaq 0x18(%rsp), %rax
movq %rsi, (%rax)
movl %edx, 0x4(%rsp)
movl %ecx, (%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
leaq 0x3e8e9(%rip), %rcx     # 0x450fc
leaq 0x3e9aa(%rip), %rsi     # 0x451c4
testl %edi, %edi
cmovneq %rcx, %rsi
movq 0x4d7b1(%rip), %rdi     # 0x53fd8
movq %rax, %rdx
callq 0xefcc
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jne 0x6869
movq 0x4d799(%rip), %rbx     # 0x53fd8
leaq 0x3e9da(%rip), %rsi     # 0x45220
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xefcc
leaq 0x3ea22(%rip), %rsi     # 0x4527c
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xefcc
jmp 0x68a0
movq 0x4d768(%rip), %rbx     # 0x53fd8
leaq 0x3ea61(%rip), %rsi     # 0x452d8
leaq 0x10(%rsp), %rdx
leaq 0x4(%rsp), %rcx
movq %rbx, %rdi
callq 0x104c1
leaq 0x3eab8(%rip), %rsi     # 0x45348
leaq 0x8(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x104c1
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x6420
movq (%rbx), %rax
movq -0x18(%rax), %rax
orl $0x104, 0x38(%rsp,%rax) # imm = 0x104
movsd 0x3d48f(%rip), %xmm0    # 0x44008
movq %rbx, %rdi
callq 0x6500
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x64e0
leaq 0x3d85f(%rip), %rsi     # 0x443f4
movq %rsp, %r14
movq %r14, %rdi
callq 0x60c0
movl %eax, %ebx
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x6bbc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6340
testl %ebx, %ebx
sete %bl
movq 0x4d3f0(%rip), %rsi     # 0x53fb8
leaq 0x20(%rsp), %rdi
callq 0x61c0
leaq 0x90(%rsp), %rdi
callq 0x6100
movl %ebx, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
jmp 0x6bee
movq %rax, %rbx
movq 0x4d3c0(%rip), %rsi     # 0x53fb8
leaq 0x20(%rsp), %rdi
callq 0x61c0
leaq 0x90(%rsp), %rdi
callq 0x6100
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
cvtss2sd (%r14), %xmm0
xorl %edi, %edi
xorl %esi, %esi
movb $0x1, %al
callq 0x64f0
movl %eax, 0x1c(%rsp)
testl %eax, %eax
js 0xc4fd
movl %eax, %r15d
incl %r15d
movq %r15, %rdi
callq 0x6040
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdx
xorps %xmm0, %xmm0
cvtss2sd (%r14), %xmm0
movq %rax, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x64f0
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6440
testl %eax, %eax
sete %bl
je 0xc4ec
movq 0x47aff(%rip), %rdi     # 0x53fd0
leaq 0x38ae6(%rip), %rsi     # 0x44fbe
leaq 0x10(%rsp), %rdx
leaq 0x1c(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x24403
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc517
callq 0x63f0
jmp 0xc517
movq 0x47acc(%rip), %rdi     # 0x53fd0
leaq 0x38ae8(%rip), %rsi     # 0x44ff3
leaq 0x10(%rsp), %rdx
callq 0xcfa8
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp            # imm = 0x348
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1d0(%rsp), %r12
movq %r12, %rdi
callq 0x6420
leaq 0x70(%rsp), %rdi
movq %r12, %rsi
callq 0xd41e
leaq 0x8(%rsp), %r12
leaq 0x70(%rsp), %r13
testq %r15, %r15
je 0x12781
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xd62d
cmpw $0x0, 0x38(%rsp)
sete %bpl
andb 0x8(%rsp), %bpl
je 0x12774
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
subq %rsi, %rdx
movq %r13, %rdi
callq 0x6400
movq 0x20(%rsp), %r15
testb %bpl, %bpl
jne 0x12737
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x12789
movl 0xc0(%rsp), %r15d
leaq 0x40878(%rip), %rax     # 0x53008
leaq 0xc8(%rsp), %r12
movq %rax, -0x58(%r12)
leaq 0x4088c(%rip), %rax     # 0x53030
movq %rax, (%r12)
movq 0x417f1(%rip), %rax     # 0x53fa0
addq $0x10, %rax
movq %rax, -0x50(%r12)
leaq 0xb0(%rsp), %rdi
callq 0x6460
movq %r12, %rdi
callq 0x6100
testq %r14, %r14
je 0x12873
testl %r15d, %r15d
js 0x12873
leaq 0x1d8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x64e0
leal 0x1(%r15), %eax
cmpq %r14, %rax
jbe 0x12845
decq %r14
leaq 0x8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x6370
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x62f0
cmpq %r12, %r15
je 0x1283b
movq 0x18(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x6340
movb $0x0, (%rbx,%r14)
movl %r14d, %r15d
jmp 0x12852
movq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0x62f0
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12873
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x6340
movq 0x4173e(%rip), %rsi     # 0x53fb8
leaq 0x1d0(%rsp), %rdi
callq 0x61c0
leaq 0x240(%rsp), %rdi
callq 0x6100
movl %r15d, %eax
addq $0x348, %rsp            # imm = 0x348
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x128e3
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x6340
jmp 0x128e3
jmp 0x128d1
movq %rax, %rbx
jmp 0x128e3
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xdcd2
movq 0x416ce(%rip), %rsi     # 0x53fb8
leaq 0x1d0(%rsp), %rdi
callq 0x61c0
leaq 0x240(%rsp), %rdi
callq 0x6100
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdx, 0x8(%rsp)
testq %rdx, %rdx
jle 0x14154
movq %rdi, %r12
leaq 0x38(%rdi), %rax
movq %rax, 0x10(%rsp)
xorl %r14d, %r14d
leaq 0x18(%rsp), %r13
movq 0x20(%rsp), %rax
movb (%rax,%r14), %bpl
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0x61e0
movq %r13, %rdi
callq 0x6160
movzbl %bpl, %ecx
movq 0x30(%rax), %rax
movzwl (%rax,%rcx,2), %r15d
movq %r13, %rdi
callq 0x6460
btl $0x9, %r15d
jae 0x1410d
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0x61e0
movq %r13, %rdi
callq 0x6160
movq (%rax), %rcx
movsbl %bpl, %esi
movq %rax, %rdi
callq *0x10(%rcx)
movl %eax, %ebp
movq %r13, %rdi
callq 0x6460
movq 0x40(%r12), %rdi
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
jae 0x1413d
movb %bpl, (%rax)
incq 0x28(%rdi)
xorl %eax, %eax
testb %al, %al
cmovneq %r14, %rbx
jne 0x1414f
incq %r14
cmpq %r14, 0x8(%rsp)
jne 0x140a7
jmp 0x14154
movzbl %bpl, %esi
movq (%rdi), %rax
callq *0x68(%rax)
cmpl $-0x1, %eax
sete %al
jmp 0x14125
movq %rbx, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1416a
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6460
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp            # imm = 0x348
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1d0(%rsp), %r12
movq %r12, %rdi
callq 0x6290
leaq 0x70(%rsp), %rdi
movq %r12, %rsi
callq 0xf446
leaq 0x8(%rsp), %r12
leaq 0x70(%rsp), %r13
testq %r15, %r15
je 0x3700f
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xf5ac
cmpw $0x0, 0x38(%rsp)
sete %bpl
andb 0x8(%rsp), %bpl
je 0x37002
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
subq %rsi, %rdx
sarq $0x2, %rdx
movq %r13, %rdi
callq 0x65c0
movq 0x20(%rsp), %r15
testb %bpl, %bpl
jne 0x36fc1
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x37017
movl 0xc0(%rsp), %r15d
leaq 0x1c22a(%rip), %rax     # 0x53248
leaq 0xc8(%rsp), %r12
movq %rax, -0x58(%r12)
leaq 0x1c23e(%rip), %rax     # 0x53270
movq %rax, (%r12)
movq 0x1cf83(%rip), %rax     # 0x53fc0
addq $0x10, %rax
movq %rax, -0x50(%r12)
leaq 0xb0(%rsp), %rdi
callq 0x6460
movq %r12, %rdi
callq 0x6100
testq %r14, %r14
je 0x3710b
testl %r15d, %r15d
js 0x3710b
leaq 0x1d8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x60d0
leal 0x1(%r15), %eax
cmpq %r14, %rax
jbe 0x370d8
leaq -0x1(%r14), %r15
leaq 0x8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x61a0
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rsi
movq %rbx, %rdi
callq 0x65d0
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x370ce
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6340
movl $0x0, (%rbx,%r14,4)
jmp 0x370e5
movq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0x65d0
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3710b
movq 0x80(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6340
movq 0x1ce7e(%rip), %rsi     # 0x53f90
leaq 0x1d0(%rsp), %rdi
callq 0x6110
leaq 0x240(%rsp), %rdi
callq 0x6100
movl %r15d, %eax
addq $0x348, %rsp            # imm = 0x348
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37180
movq 0x80(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6340
jmp 0x37180
jmp 0x3716e
movq %rax, %rbx
jmp 0x37180
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xfb88
movq 0x1ce09(%rip), %rsi     # 0x53f90
leaq 0x1d0(%rsp), %rdi
callq 0x6110
leaq 0x240(%rsp), %rdi
callq 0x6100
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37cb7
movl (%rcx), %ecx
xorl %eax, %eax
jmp 0x64b0
subq $0x1008, %rsp           # imm = 0x1008
movl (%rcx), %ecx
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
callq 0x64b0
addq $0x1008, %rsp           # imm = 0x1008
retq