LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/calmopyrin[P]tedplay/tedplay.cpp
// Function: readFile(char*, unsigned char**, unsigned long*)
unsigned int readFile(char *fName, unsigned char **bufferPtr, size_t *bLen)
{
	std::FILE *file = (std::FILE *) 0;

	if (!fName)
		return 2;

	try {
		size_t flen;
		file = std::fopen(fName, "rb");
		if (!file)
			return 3;
		std::fseek(file, 0, SEEK_END);
		flen = std::ftell(file);
		if (flen > MAX_BUFFER_SIZE) flen = MAX_BUFFER_SIZE;
		std::fseek(file, 0, SEEK_SET);
		*bufferPtr = inputBuffer;
		size_t r = std::fread(*bufferPtr, flen, 1, file);
		*bLen = flen;
		fclose(file);
	} catch(char *str) {
		std::cerr << "Error opening " << fName << std::endl;
		std::cerr << "    exception: " << str << std::endl;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b662
movl $0x2, -0x4(%rbp)
jmp 0x1b806
movq -0x10(%rbp), %rdi
leaq 0x2a9f(%rip), %rsi      # 0x1e10c
callq 0x32f0
movq %rax, -0x58(%rbp)
jmp 0x1b678
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1b74d
movl $0x3, -0x4(%rbp)
jmp 0x1b806
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1b812
movq -0x38(%rbp), %rdi
callq 0x30e0
movq %rax, -0x50(%rbp)
movq 0x8929(%rip), %rdi      # 0x23ff0
leaq 0x2a41(%rip), %rsi      # 0x1e10f
callq 0x3250
movq %rax, -0x60(%rbp)
jmp 0x1b6d9
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3250
movq %rax, -0x68(%rbp)
jmp 0x1b6ec
movq -0x68(%rbp), %rdi
movq 0x88c1(%rip), %rsi      # 0x23fb8
callq 0x3290
jmp 0x1b6fe
movq 0x88eb(%rip), %rdi      # 0x23ff0
leaq 0x2a12(%rip), %rsi      # 0x1e11e
callq 0x3250
movq %rax, -0x70(%rbp)
jmp 0x1b717
movq -0x70(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x3250
movq %rax, -0x78(%rbp)
jmp 0x1b72a
movq -0x78(%rbp), %rdi
movq 0x8883(%rip), %rsi      # 0x23fb8
callq 0x3290
jmp 0x1b73c
movl $0x1, -0x4(%rbp)
callq 0x33e0
jmp 0x1b806
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x32e0
jmp 0x1b761
movq -0x28(%rbp), %rdi
callq 0x3030
movq %rax, -0x80(%rbp)
jmp 0x1b770
movq -0x80(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x10000, -0x30(%rbp)   # imm = 0x10000
jbe 0x1b78a
movq $0x10000, -0x30(%rbp)   # imm = 0x10000
movq -0x28(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x32e0
jmp 0x1b799
movq -0x18(%rbp), %rax
leaq 0x1ab0c(%rip), %rcx     # 0x362b0
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl $0x1, %edx
callq 0x33a0
movq %rax, -0x88(%rbp)
jmp 0x1b7c9
movq -0x88(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x3260
jmp 0x1b7ea
jmp 0x1b7ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x33e0
jmp 0x1b812
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3410
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/calmopyrin[P]tedplay/tedplay.cpp
// Function: machineInit(unsigned int, unsigned int)
TED *machineInit(unsigned int sampleRate, unsigned int filterOrder)
{
	ted = new TED;
	ted->initFilter(sampleRate, filterOrder);
	cpu = new CPU(ted, ted->Ram + 0xff09, ted->Ram + 0x100);
	ted->cpuptr = cpu;
	ted->loadroms();
	machineReset();
	return ted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0xb71e0, %edi          # imm = 0xB71E0
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
callq 0x15f30
jmp 0x1bad9
movq -0x20(%rbp), %rax
movq %rax, 0x1a7bc(%rip)     # 0x362a0
movq 0x1a7b5(%rip), %rdi     # 0x362a0
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x1a360
movl $0xa8, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq 0x1a78f(%rip), %rsi     # 0x362a0
movq %rsi, %rdx
addq $0x55ec9, %rdx          # imm = 0x55EC9
movq %rsi, %rcx
addq $0x460c0, %rcx          # imm = 0x460C0
callq 0x4bb0
jmp 0x1bb2c
movq -0x28(%rbp), %rax
movq %rax, 0x2a779(%rip)     # 0x462b0
movq 0x2a772(%rip), %rcx     # 0x462b0
movq 0x1a75b(%rip), %rax     # 0x362a0
movq %rcx, 0x45fb8(%rax)
movq 0x1a74d(%rip), %rdi     # 0x362a0
callq 0x16770
callq 0x1ba90
movq 0x1a73c(%rip), %rax     # 0x362a0
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0xb71e0, %esi          # imm = 0xB71E0
callq 0x3280
jmp 0x1bba0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0xa8, %esi
callq 0x3280
movq -0x10(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/calmopyrin[P]tedplay/tedplay.cpp
// Function: dumpMem(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void dumpMem(std::string name)
{
	FILE *fp = fopen(name.c_str(), "wb");
	if (!fp)
		return;
	for(unsigned int i = 0; i <= 0xffff; i++) {
		fputc(ted->Read(i), fp);
	}
	fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x30f0
movq %rax, %rdi
leaq 0x2468(%rip), %rsi      # 0x1e063
callq 0x32f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1bc0d
jmp 0x1bc4d
movl $0x0, -0x14(%rbp)
cmpl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
ja 0x1bc44
movq 0x1a67c(%rip), %rdi     # 0x362a0
movl -0x14(%rbp), %esi
movq (%rdi), %rax
callq *0x8(%rax)
movzbl %al, %edi
movq -0x10(%rbp), %rsi
callq 0x3320
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1bc14
movq -0x10(%rbp), %rdi
callq 0x3260
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/calmopyrin[P]tedplay/tedplay.cpp
// Function: machineShutDown()
void machineShutDown()
{
	if(ted) {
		delete ted;
		ted = 0;
	}
	if (cpu) {
		delete cpu;
		cpu = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x1a600(%rip)     # 0x362a0
je 0x1bcc8
movq 0x1a5f7(%rip), %rax     # 0x362a0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x1bcbd
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x1a5d8(%rip) # 0x362a0
cmpq $0x0, 0x2a5e0(%rip)     # 0x462b0
je 0x1bd05
movq 0x2a5d7(%rip), %rax     # 0x462b0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1bcfa
movq -0x10(%rbp), %rdi
callq 0x130e0
movq -0x10(%rbp), %rdi
movl $0xa8, %esi
callq 0x3280
movq $0x0, 0x2a5ab(%rip) # 0x462b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/calmopyrin[P]tedplay/tedplay.cpp
// Function: tedplayPause()
void tedplayPause()
{
	if (player && playState == 1) {
		player->pause();
		player->lock();
		playState = 2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x2a59c(%rip)     # 0x462b8
je 0x1bd4b
cmpl $0x1, 0x2a59b(%rip)     # 0x462c0
jne 0x1bd4b
movq 0x2a58a(%rip), %rdi     # 0x462b8
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x2a57d(%rip), %rdi     # 0x462b8
movq (%rdi), %rax
callq *0x38(%rax)
movl $0x2, 0x2a575(%rip)     # 0x462c0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/calmopyrin[P]tedplay/tedplay.cpp
// Function: tedplayPlay()
void tedplayPlay()
{
	if (player && !(playState == 1)) {
		player->unlock();
		if (!playState)
			ted->oscillatorReset();
		player->play();
		playState = 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x2a55c(%rip)     # 0x462b8
je 0x1bda0
cmpl $0x1, 0x2a55b(%rip)     # 0x462c0
je 0x1bda0
movq 0x2a54a(%rip), %rdi     # 0x462b8
movq (%rdi), %rax
callq *0x40(%rax)
cmpl $0x0, 0x2a545(%rip)     # 0x462c0
jne 0x1bd89
movq 0x1a51c(%rip), %rdi     # 0x362a0
callq 0x19970
movq 0x2a528(%rip), %rdi     # 0x462b8
movq (%rdi), %rax
callq *0x10(%rax)
movl $0x1, 0x2a520(%rip)     # 0x462c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/calmopyrin[P]tedplay/tedplay.cpp
// Function: tedplayStop()
void tedplayStop()
{
	if (player && playState) {
		player->stop();
		player->lock();
	}
	cpu->setPC(playerStartAddress);
	playState = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x2a4fc(%rip)     # 0x462b8
je 0x1bde1
cmpl $0x0, 0x2a4fb(%rip)     # 0x462c0
je 0x1bde1
movq 0x2a4ea(%rip), %rdi     # 0x462b8
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x2a4dd(%rip), %rdi     # 0x462b8
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x2a4c8(%rip), %rdi     # 0x462b0
movl $0xfe00, %esi           # imm = 0xFE00
callq 0x4ff0
movl $0x0, 0x2a4c4(%rip)     # 0x462c0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/calmopyrin[P]tedplay/tedplay.cpp
// Function: tedPlaySetWaveform(unsigned int, unsigned int)
void tedPlaySetWaveform(unsigned int channel, unsigned int wave)
{
	bool wasPlaying = (playState == 1);
	
	if (wasPlaying)
		tedplayPause();
	if (ted) {
		ted->selectWaveForm(channel, wave);
	}
	if (wasPlaying)
		tedplayPlay();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x1, 0x2a38b(%rip)     # 0x462c0
sete %al
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1bf48
callq 0x1bd10
cmpq $0x0, 0x1a350(%rip)     # 0x362a0
je 0x1bf64
movq 0x1a347(%rip), %rdi     # 0x362a0
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x1a290
testb $0x1, -0x9(%rbp)
je 0x1bf6f
callq 0x1bd50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/calmopyrin[P]tedplay/tedplay.cpp
// Function: tedplayClose()
void tedplayClose()
{
	if (player) {
		player->stop();
		delete player;
		player = 0;
	}
	machineShutDown();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x2a328(%rip)     # 0x462b8
je 0x1bfc5
movq 0x2a31f(%rip), %rdi     # 0x462b8
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x2a312(%rip), %rax     # 0x462b8
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x1bfba
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x2a2f3(%rip) # 0x462b8
callq 0x1bc90
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/calmopyrin[P]tedplay/tedplay.cpp
// Function: copyPetsciiToAsc(char*, char*, unsigned int)
static void copyPetsciiToAsc(char* to, char* from, unsigned int size)
{
	if (size) {
		unsigned int i = size - 1;
		do {
			to[i] = convertToAscii((unsigned char)from[i], false);
		} while (i--);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1c372
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
xorl %esi, %esi
movzbl (%rax,%rcx), %edi
callq 0x1ae60
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x18(%rbp)
cmpl $0x0, %eax
jne 0x1c342
jmp 0x1c372
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/example/example.c
// Function: report_error
int report_error(void) {
    char message[SIR_MAXERROR] = {0};
    (void)sir_geterror(message);
    (void)fprintf(stderr, SIR_BREDB("libsir error: ") SIR_RED("%s%s"), message, SIR_EOL);
    return EXIT_FAILURE;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rsp, %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x21c0
movq %rsp, %rdi
callq 0x2a20
movq 0x13773(%rip), %rax     # 0x15ff8
movq (%rax), %rdi
movq %rsp, %rdx
leaq 0xdbaa(%rip), %rsi      # 0x1043c
leaq 0xe08f(%rip), %rcx      # 0x10928
movb $0x0, %al
callq 0x2260
movl $0x1, %eax
addq $0x108, %rsp            # imm = 0x108
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/example/example.c
// Function: report_warning
void report_warning(const char* warning) {
    if (_sir_validstrnofail(warning)) {
        char message[SIR_MAXERROR] = {0};
        (void)sir_geterror(message);
        (void)fprintf(stderr, SIR_BYELLOWB("%s! ") SIR_YELLOW("libsir error: %s%s"), warning, message, SIR_EOL);
    }
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x100(%rsp)
movq 0x100(%rsp), %rdi
xorl %esi, %esi
leaq 0xdba7(%rip), %rdx      # 0x10477
leaq 0xdbaf(%rip), %rcx      # 0x10486
movl $0xcf, %r8d
callq 0x2940
testb $0x1, %al
jne 0x28e8
jmp 0x2929
movq %rsp, %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x21c0
movq %rsp, %rdi
callq 0x2a20
movq 0x136f2(%rip), %rax     # 0x15ff8
movq (%rax), %rdi
movq 0x100(%rsp), %rdx
movq %rsp, %rcx
leaq 0xdb75(%rip), %rsi      # 0x10490
leaq 0xe006(%rip), %r8       # 0x10928
movb $0x0, %al
callq 0x2260
addq $0x108, %rsp            # imm = 0x108
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/include/sir/helpers.h
// Function: _sir_validstr
static inline
bool __sir_validstr(const char* restrict str, bool fail, const char* func,
    const char* file, uint32_t line) {
    bool valid = str && *str != '\0';
    if (fail && !valid) {
        SIR_ASSERT(!valid && fail);
        (void)__sir_seterror(_SIR_E_STRING, func, file, line);
    }
    return valid;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x20(%rsp)
movb %al, 0x2(%rsp)
je 0x2981
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0x2(%rsp)
movb 0x2(%rsp), %al
andb $0x1, %al
movb %al, 0x3(%rsp)
testb $0x1, 0x1f(%rsp)
je 0x29b1
testb $0x1, 0x3(%rsp)
jne 0x29b1
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
movl $0x800a0000, %edi       # imm = 0x800A0000
callq 0x3940
movb 0x3(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sir.c
// Function: sir_debug
bool sir_debug(PRINTF_FORMAT const char* format, ...) {
    _SIR_L_START(format);
    ret = _sir_logv(SIRL_DEBUG, format, args);
    _SIR_L_END();
    return ret;
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x2aac
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xd8(%rsp)
movb $0x0, 0xd7(%rsp)
movq 0xd8(%rsp), %rdi
movl $0x1, %esi
leaq 0xd9e6(%rip), %rdx      # 0x104cf
leaq 0xd9e9(%rip), %rcx      # 0x104d9
movl $0x46, %r8d
callq 0x2b80
testb $0x1, %al
jne 0x2b09
movb $0x0, 0xe7(%rsp)
jmp 0x2b6c
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xd8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
movl $0x80, %edi
callq 0xacb0
andb $0x1, %al
movb %al, 0xd7(%rsp)
leaq 0xb0(%rsp), %rax
movb 0xd7(%rsp), %al
andb $0x1, %al
movb %al, 0xe7(%rsp)
movb 0xe7(%rsp), %al
addq $0xe8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/include/sir/helpers.h
// Function: _sir_validptr
static inline
bool __sir_validptr(const void* restrict p, bool fail, const char* func,
    const char* file, uint32_t line) {
    bool valid = NULL != p;
    if (fail && !valid) {
        (void)__sir_seterror(_SIR_E_NULLPTR, func, file, line);
        SIR_ASSERT(!valid && fail);
    }
    return valid;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
xorl %eax, %eax
cmpq 0x20(%rsp), %rax
setne %al
andb $0x1, %al
movb %al, 0x3(%rsp)
testb $0x1, 0x1f(%rsp)
je 0x2bd7
testb $0x1, 0x3(%rsp)
jne 0x2bd7
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
movl $0x800b0000, %edi       # imm = 0x800B0000
callq 0x3940
movb 0x3(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sir.c
// Function: sir_info
bool sir_info(PRINTF_FORMAT const char* format, ...) {
    _SIR_L_START(format);
    ret = _sir_logv(SIRL_INFO, format, args);
    _SIR_L_END();
    return ret;
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x2c2c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xd8(%rsp)
movb $0x0, 0xd7(%rsp)
movq 0xd8(%rsp), %rdi
movl $0x1, %esi
leaq 0xd876(%rip), %rdx      # 0x104df
leaq 0xd869(%rip), %rcx      # 0x104d9
movl $0x4e, %r8d
callq 0x2b80
testb $0x1, %al
jne 0x2c89
movb $0x0, 0xe7(%rsp)
jmp 0x2cec
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xd8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
movl $0x40, %edi
callq 0xacb0
andb $0x1, %al
movb %al, 0xd7(%rsp)
leaq 0xb0(%rsp), %rax
movb 0xd7(%rsp), %al
andb $0x1, %al
movb %al, 0xe7(%rsp)
movb 0xe7(%rsp), %al
addq $0xe8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sir.c
// Function: sir_notice
bool sir_notice(PRINTF_FORMAT const char* format, ...) {
    _SIR_L_START(format);
    ret = _sir_logv(SIRL_NOTICE, format, args);
    _SIR_L_END();
    return ret;
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x2d3c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xd8(%rsp)
movb $0x0, 0xd7(%rsp)
movq 0xd8(%rsp), %rdi
movl $0x1, %esi
leaq 0xd76f(%rip), %rdx      # 0x104e8
leaq 0xd759(%rip), %rcx      # 0x104d9
movl $0x56, %r8d
callq 0x2b80
testb $0x1, %al
jne 0x2d99
movb $0x0, 0xe7(%rsp)
jmp 0x2dfc
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xd8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
movl $0x20, %edi
callq 0xacb0
andb $0x1, %al
movb %al, 0xd7(%rsp)
leaq 0xb0(%rsp), %rax
movb 0xd7(%rsp), %al
andb $0x1, %al
movb %al, 0xe7(%rsp)
movb 0xe7(%rsp), %al
addq $0xe8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sir.c
// Function: sir_warn
bool sir_warn(PRINTF_FORMAT const char* format, ...) {
    _SIR_L_START(format);
    ret = _sir_logv(SIRL_WARN, format, args);
    _SIR_L_END();
    return ret;
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x2e4c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xd8(%rsp)
movb $0x0, 0xd7(%rsp)
movq 0xd8(%rsp), %rdi
movl $0x1, %esi
leaq 0xd66a(%rip), %rdx      # 0x104f3
leaq 0xd649(%rip), %rcx      # 0x104d9
movl $0x5e, %r8d
callq 0x2b80
testb $0x1, %al
jne 0x2ea9
movb $0x0, 0xe7(%rsp)
jmp 0x2f0c
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xd8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
movl $0x10, %edi
callq 0xacb0
andb $0x1, %al
movb %al, 0xd7(%rsp)
leaq 0xb0(%rsp), %rax
movb 0xd7(%rsp), %al
andb $0x1, %al
movb %al, 0xe7(%rsp)
movb 0xe7(%rsp), %al
addq $0xe8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sir.c
// Function: sir_error
bool sir_error(PRINTF_FORMAT const char* format, ...) {
    _SIR_L_START(format);
    ret = _sir_logv(SIRL_ERROR, format, args);
    _SIR_L_END();
    return ret;
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x2f5c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xd8(%rsp)
movb $0x0, 0xd7(%rsp)
movq 0xd8(%rsp), %rdi
movl $0x1, %esi
leaq 0xd563(%rip), %rdx      # 0x104fc
leaq 0xd539(%rip), %rcx      # 0x104d9
movl $0x66, %r8d
callq 0x2b80
testb $0x1, %al
jne 0x2fb9
movb $0x0, 0xe7(%rsp)
jmp 0x301c
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xd8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
movl $0x8, %edi
callq 0xacb0
andb $0x1, %al
movb %al, 0xd7(%rsp)
leaq 0xb0(%rsp), %rax
movb 0xd7(%rsp), %al
andb $0x1, %al
movb %al, 0xe7(%rsp)
movb 0xe7(%rsp), %al
addq $0xe8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sir.c
// Function: sir_crit
bool sir_crit(PRINTF_FORMAT const char* format, ...) {
    _SIR_L_START(format);
    ret = _sir_logv(SIRL_CRIT, format, args);
    _SIR_L_END();
    return ret;
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x306c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xd8(%rsp)
movb $0x0, 0xd7(%rsp)
movq 0xd8(%rsp), %rdi
movl $0x1, %esi
leaq 0xd45d(%rip), %rdx      # 0x10506
leaq 0xd429(%rip), %rcx      # 0x104d9
movl $0x6e, %r8d
callq 0x2b80
testb $0x1, %al
jne 0x30c9
movb $0x0, 0xe7(%rsp)
jmp 0x312c
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xd8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
movl $0x4, %edi
callq 0xacb0
andb $0x1, %al
movb %al, 0xd7(%rsp)
leaq 0xb0(%rsp), %rax
movb 0xd7(%rsp), %al
andb $0x1, %al
movb %al, 0xe7(%rsp)
movb 0xe7(%rsp), %al
addq $0xe8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sir.c
// Function: sir_alert
bool sir_alert(PRINTF_FORMAT const char* format, ...) {
    _SIR_L_START(format);
    ret = _sir_logv(SIRL_ALERT, format, args);
    _SIR_L_END();
    return ret;
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x317c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xd8(%rsp)
movb $0x0, 0xd7(%rsp)
movq 0xd8(%rsp), %rdi
movl $0x1, %esi
leaq 0xd356(%rip), %rdx      # 0x1050f
leaq 0xd319(%rip), %rcx      # 0x104d9
movl $0x76, %r8d
callq 0x2b80
testb $0x1, %al
jne 0x31d9
movb $0x0, 0xe7(%rsp)
jmp 0x323c
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xd8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
movl $0x2, %edi
callq 0xacb0
andb $0x1, %al
movb %al, 0xd7(%rsp)
leaq 0xb0(%rsp), %rax
movb 0xd7(%rsp), %al
andb $0x1, %al
movb %al, 0xe7(%rsp)
movb 0xe7(%rsp), %al
addq $0xe8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sir.c
// Function: sir_emerg
bool sir_emerg(PRINTF_FORMAT const char* format, ...) {
    _SIR_L_START(format);
    ret = _sir_logv(SIRL_EMERG, format, args);
    _SIR_L_END();
    return ret;
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x328c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xd8(%rsp)
movb $0x0, 0xd7(%rsp)
movq 0xd8(%rsp), %rdi
movl $0x1, %esi
leaq 0xd250(%rip), %rdx      # 0x10519
leaq 0xd209(%rip), %rcx      # 0x104d9
movl $0x7e, %r8d
callq 0x2b80
testb $0x1, %al
jne 0x32e9
movb $0x0, 0xe7(%rsp)
jmp 0x334c
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xd8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
movl $0x1, %edi
callq 0xacb0
andb $0x1, %al
movb %al, 0xd7(%rsp)
leaq 0xb0(%rsp), %rax
movb 0xd7(%rsp), %al
andb $0x1, %al
movb %al, 0xe7(%rsp)
movb 0xe7(%rsp), %al
addq $0xe8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sir.c
// Function: sir_settextstyle
bool sir_settextstyle(sir_level level, sir_textattr attr, sir_textcolor fg,
    sir_textcolor bg) {
    sir_textstyle style = {
        attr,
        fg,
        bg
    };

    return _sir_settextstyle(level, &style);
}

// Assembly:
subq $0x28, %rsp
movw %di, %ax
movw %ax, 0x26(%rsp)
movl %esi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0xc(%rsp), %rsi
movzwl 0x26(%rsp), %edi
callq 0xe5c0
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/include/sir/helpers.h
// Function: sir_makergb
static inline
sir_textcolor _sir_makergb(sir_textcolor r, sir_textcolor g, sir_textcolor b) {
    sir_textcolor retval = 0;
    _sir_setredincolor(retval, r);
    _sir_setgreenincolor(retval, g);
    _sir_setblueincolor(retval, b);
    return retval;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl %edx, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
movl -0x4(%rsp), %eax
shll $0x10, %eax
andl $0xff0000, %eax         # imm = 0xFF0000
orl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x8(%rsp), %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
orl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
andl $0xff, %eax
orl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sir.c
// Function: sir_sysloglevels
bool sir_sysloglevels(sir_levels levels) {
#if !defined(SIR_NO_SYSTEM_LOGGERS)
    _sir_defaultlevels(&levels, sir_syslog_def_lvls);
    sir_update_config_data data = {SIRU_LEVELS, &levels, NULL, NULL, NULL};
    return _sir_writeinit(&data, _sir_sysloglevels);
#else
    SIR_UNUSED(levels);
    return _sir_seterror(_SIR_E_UNAVAIL);
#endif
}

// Assembly:
subq $0x38, %rsp
movw %di, %ax
movw %ax, 0x36(%rsp)
leaq 0x36(%rsp), %rdi
movl $0x3f, %esi
callq 0x3450
movl $0x1, 0x8(%rsp)
leaq 0x36(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x696c(%rip), %rsi      # 0xa170
callq 0xa970
andb $0x1, %al
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sir.c
// Function: sir_syslogopts
bool sir_syslogopts(sir_options opts) {
#if !defined(SIR_NO_SYSTEM_LOGGERS)
    _sir_defaultopts(&opts, sir_syslog_def_opts);
    sir_update_config_data data = {SIRU_OPTIONS, NULL, &opts, NULL, NULL};
    return _sir_writeinit(&data, _sir_syslogopts);
#else
    SIR_UNUSED(opts);
    return _sir_seterror(_SIR_E_UNAVAIL);
#endif
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
leaq 0x34(%rsp), %rdi
movl $0x7f00, %esi           # imm = 0x7F00
callq 0x34f0
movl $0x2, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x34(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x6c60(%rip), %rsi      # 0xa4c0
callq 0xa970
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirerrors.c
// Function: _sir_seterror
bool __sir_seterror(uint32_t err, const char* func, const char* file, uint32_t line) {
    if (_sir_validerror(err)) {
        _sir_te.lasterror = err;
        _sir_te.loc.func  = func;
        _sir_te.loc.file  = file;
        _sir_te.loc.line  = line;

        if (_SIR_E_PLATFORM != err) {
            _sir_te.os_code = 0;
            _sir_resetstr(_sir_te.os_msg);
        }
    }
#if defined(DEBUG) && defined(SIR_SELFLOG)
    if (_SIR_E_NOERROR != err) {
        char errmsg[SIR_MAXERROR] = {0};
        _sir_geterror(errmsg);
        __sir_selflog(func, file, line, "%s", errmsg);
    }
#endif
    return false;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl 0x34(%rsp), %edi
callq 0x3a50
testb $0x1, %al
jne 0x3968
jmp 0x3a43
movl 0x34(%rsp), %eax
movl %eax, 0x4(%rsp)
movq %fs:0x0, %rax
movl 0x4(%rsp), %ecx
leaq -0x150(%rax), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %fs:0x0, %rax
movq 0x8(%rsp), %rcx
leaq -0x150(%rax), %rax
movq %rcx, 0x108(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %fs:0x0, %rax
movq 0x10(%rsp), %rcx
leaq -0x150(%rax), %rax
movq %rcx, 0x110(%rax)
movl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
movq %fs:0x0, %rax
movl 0x18(%rsp), %ecx
leaq -0x150(%rax), %rax
movl %ecx, 0x118(%rax)
movl $0x80170000, %eax       # imm = 0x80170000
cmpl 0x34(%rsp), %eax
je 0x3a41
movq %fs:0x0, %rax
leaq -0x150(%rax), %rax
movl $0x0, 0x4(%rax)
movq %fs:0x0, %rax
leaq -0x150(%rax), %rdi
addq $0x8, %rdi
callq 0x3a90
jmp 0x3a43
xorl %eax, %eax
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirerrors.c
// Function: _sir_setoserror
void __sir_setoserror(int code, const char* msg, const char* func, const char* file, uint32_t line) {
    _sir_te.os_code = code;
    _sir_resetstr(_sir_te.os_msg);

    if (_sir_validstrnofail(msg))
        (void)_sir_strncpy(_sir_te.os_msg, SIR_MAXERROR, msg, SIR_MAXERROR);

    (void)__sir_seterror(_SIR_E_PLATFORM, func, file, line);
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
movl 0x24(%rsp), %eax
movl %eax, (%rsp)
movq %fs:0x0, %rax
movl (%rsp), %ecx
leaq -0x150(%rax), %rax
movl %ecx, 0x4(%rax)
movq %fs:0x0, %rax
leaq -0x150(%rax), %rdi
addq $0x8, %rdi
callq 0x3a90
movq 0x18(%rsp), %rdi
xorl %esi, %esi
leaq 0xca17(%rip), %rdx      # 0x1052d
leaq 0xca21(%rip), %rcx      # 0x1053e
movl $0x70, %r8d
callq 0x3b80
testb $0x1, %al
jne 0x3b2e
jmp 0x3b57
movq %fs:0x0, %rax
leaq -0x150(%rax), %rdi
addq $0x8, %rdi
movq 0x18(%rsp), %rdx
movl $0x100, %ecx            # imm = 0x100
movq %rcx, %rsi
callq 0x83d0
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
movl $0x80170000, %edi       # imm = 0x80170000
callq 0x3940
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirerrors.c
// Function: _sir_handleerr
bool __sir_handleerr(int code, const char* func, const char* file, uint32_t line) {
    if (SIR_E_NOERROR != code) {
        char message[SIR_MAXERROR] = {0};
        int finderr                = 0;
        errno                      = SIR_E_NOERROR;

#if defined(__HAVE_XSI_STRERROR_R__)
        _sir_selflog("using XSI strerror_r");
        finderr = strerror_r(code, message, SIR_MAXERROR);
# if defined(__HAVE_XSI_STRERROR_R_ERRNO__)
        _sir_selflog("using XSI strerror_r for glibc < 2.13");
        if (finderr == -1)
            finderr = errno;
# endif
#elif defined(__HAVE_GNU_STRERROR_R__)
        _sir_selflog("using GNU strerror_r");
        const char* tmp = strerror_r(code, message, SIR_MAXERROR);
        if (tmp != message)
            (void)_sir_strncpy(message, SIR_MAXERROR, tmp, SIR_MAXERROR);
#elif defined(__HAVE_STRERROR_S__)
        _sir_selflog("using strerror_s");
        finderr = (int)strerror_s(message, SIR_MAXERROR, code);
#else
        _sir_selflog("using strerror");
        const char* tmp = strerror(code);
        (void)_sir_strncpy(message, SIR_MAXERROR, tmp, strnlen(tmp, SIR_MAXERROR));
#endif
        if (0 == finderr) { //-V547
            __sir_setoserror(code, message, func, file, line);
#if defined(__HAVE_XSI_STRERROR_R__) || defined(__HAVE_STRERROR_S__)
        } else {
            /* Per my reading of the man pages, GNU strerror_r and normal strerror "can't fail";
             * they simply return a string such as "Unknown nnn error" if unable to look up an
             * error code.
             */
# if defined(__HAVE_XSI_STRERROR_R__)
            _sir_selflog("strerror_r failed! error: %d", finderr);
# elif defined(__HAVE_STRERROR_S__)
            _sir_selflog("strerror_s failed! error: %d", finderr);
# endif
#endif
        }
    }
    return false;
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movl %edi, 0x134(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movl %ecx, 0x11c(%rsp)
movl $0x1, %eax
cmpl 0x134(%rsp), %eax
je 0x3cda
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x21c0
movl $0x0, 0xc(%rsp)
callq 0x2070
movl $0x1, (%rax)
leaq 0xc8e8(%rip), %rdi      # 0x1054a
movb $0x0, %al
callq 0x3cf0
movl 0x134(%rsp), %edi
leaq 0x10(%rsp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x22f0
movq %rax, (%rsp)
movq (%rsp), %rax
leaq 0x10(%rsp), %rcx
cmpq %rcx, %rax
je 0x3ca7
leaq 0x10(%rsp), %rdi
movq (%rsp), %rdx
movl $0x100, %ecx            # imm = 0x100
movq %rcx, %rsi
callq 0x83d0
xorl %eax, %eax
cmpl 0xc(%rsp), %eax
jne 0x3cd8
movl 0x134(%rsp), %edi
leaq 0x10(%rsp), %rsi
movq 0x128(%rsp), %rdx
movq 0x120(%rsp), %rcx
movl 0x11c(%rsp), %r8d
callq 0x3ab0
jmp 0x3cda
xorl %eax, %eax
andb $0x1, %al
addq $0x138, %rsp            # imm = 0x138
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirerrors.c
// Function: sir_reset_tls_error
void _sir_reset_tls_error(void) {
    _sir_te.lasterror = _SIR_E_NOERROR;
    _sir_te.os_code   = 0;
    _sir_resetstr(_sir_te.os_msg);
    _sir_te.loc.func = SIR_UNKNOWN;
    _sir_te.loc.file = SIR_UNKNOWN;
    _sir_te.loc.line = 0U;
}

// Assembly:
pushq %rax
movq %fs:0x0, %rax
leaq -0x150(%rax), %rax
movl $0x80010000, (%rax)     # imm = 0x80010000
movq %fs:0x0, %rax
leaq -0x150(%rax), %rax
movl $0x0, 0x4(%rax)
movq %fs:0x0, %rax
leaq -0x150(%rax), %rdi
addq $0x8, %rdi
callq 0x3a90
movq %fs:0x0, %rax
leaq -0x150(%rax), %rax
leaq 0xbe0d(%rip), %rcx      # 0x10387
movq %rcx, 0x108(%rax)
movq %fs:0x0, %rax
leaq -0x150(%rax), %rax
leaq 0xbdec(%rip), %rcx      # 0x10387
movq %rcx, 0x110(%rax)
movq %fs:0x0, %rax
leaq -0x150(%rax), %rax
movl $0x0, 0x118(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirfilecache.c
// Function: sir_addfile
sirfileid _sir_addfile(const char* path, sir_levels levels, sir_options opts) {
    (void)_sir_seterror(_SIR_E_NOERROR);

    if (!_sir_sanity())
        return 0U;

    _SIR_LOCK_SECTION(sirfcache, sfc, SIRMI_FILECACHE, 0U);

    _sir_defaultlevels(&levels, sir_file_def_lvls);
    _sir_defaultopts(&opts, sir_file_def_opts);

    sirfileid retval = _sir_fcache_add(sfc, path, levels, opts);
    _SIR_UNLOCK_SECTION(SIRMI_FILECACHE);

    return retval;
}

// Assembly:
subq $0x28, %rsp
movw %si, %ax
movq %rdi, 0x18(%rsp)
movw %ax, 0x16(%rsp)
movl %edx, 0x10(%rsp)
movl $0x80010000, %edi       # imm = 0x80010000
leaq 0xc27f(%rip), %rsi      # 0x10870
leaq 0xc285(%rip), %rdx      # 0x1087d
movl $0x28, %ecx
callq 0x3940
callq 0x9d10
testb $0x1, %al
jne 0x4618
movl $0x0, 0x24(%rsp)
jmp 0x46a7
movl $0x1, %edi
callq 0x9650
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4656
movl $0x800f0000, %edi       # imm = 0x800F0000
leaq 0xc235(%rip), %rsi      # 0x10870
leaq 0xc23b(%rip), %rdx      # 0x1087d
movl $0x2d, %ecx
callq 0x3940
movl $0x0, 0x24(%rsp)
jmp 0x46a7
jmp 0x4658
leaq 0x16(%rsp), %rdi
movl $0xff, %esi
callq 0x46b0
leaq 0x10(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x46f0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movw 0x16(%rsp), %ax
movl 0x10(%rsp), %ecx
movzwl %ax, %edx
callq 0x4720
movl %eax, 0x4(%rsp)
movl $0x1, %edi
callq 0x9aa0
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirfilecache.c
// Function: sir_updatefile
bool _sir_updatefile(sirfileid id, const sir_update_config_data* data) {
    (void)_sir_seterror(_SIR_E_NOERROR);

    if (!_sir_sanity() || !_sir_validfileid(id) || !_sir_validupdatedata(data))
        return false;

    _SIR_LOCK_SECTION(const sirfcache, sfc, SIRMI_FILECACHE, false);
    bool retval = _sir_fcache_update(sfc, id, data);
    _SIR_UNLOCK_SECTION(SIRMI_FILECACHE);

    return retval;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x80010000, %edi       # imm = 0x80010000
leaq 0xbef3(%rip), %rsi      # 0x1088c
leaq 0xbedd(%rip), %rdx      # 0x1087d
movl $0x39, %ecx
callq 0x3940
callq 0x9d10
testb $0x1, %al
jne 0x49b5
jmp 0x49e5
movl 0x20(%rsp), %edi
callq 0x4a70
testb $0x1, %al
jne 0x49c4
jmp 0x49e5
movq 0x18(%rsp), %rdi
leaq 0xbebc(%rip), %rsi      # 0x1088c
leaq 0xbea6(%rip), %rdx      # 0x1087d
movl $0x3b, %ecx
callq 0x7ad0
testb $0x1, %al
jne 0x49ec
movb $0x0, 0x27(%rsp)
jmp 0x4a56
movl $0x1, %edi
callq 0x9650
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4a27
movl $0x800f0000, %edi       # imm = 0x800F0000
leaq 0xbe7d(%rip), %rsi      # 0x1088c
leaq 0xbe67(%rip), %rdx      # 0x1087d
movl $0x3e, %ecx
callq 0x3940
movb $0x0, 0x27(%rsp)
jmp 0x4a56
jmp 0x4a29
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0x4a80
andb $0x1, %al
movb %al, 0xf(%rsp)
movl $0x1, %edi
callq 0x9aa0
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirfilecache.c
// Function: sir_fcache_update
bool _sir_fcache_update(const sirfcache* sfc, sirfileid id, const sir_update_config_data* data) {
    bool retval = _sir_validptr(sfc) && _sir_validfileid(id) && _sir_validupdatedata(data);

    if (retval) {
        sirfile* found = _sir_fcache_find(sfc, (const void*)&id, _sir_fcache_pred_id);
        retval = found ? _sirfile_update(found, data) : _sir_seterror(_SIR_E_NOITEM);
    }

    return retval;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0xc1b3(%rip), %rdx      # 0x10c56
leaq 0xbdd3(%rip), %rcx      # 0x1087d
movl $0x1bc, %r8d            # imm = 0x1BC
callq 0x5200
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4ac4
jmp 0x4afd
movl 0x2c(%rsp), %edi
callq 0x4a70
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4adc
jmp 0x4afd
movq 0x20(%rsp), %rdi
leaq 0xc16e(%rip), %rsi      # 0x10c56
leaq 0xbd8e(%rip), %rdx      # 0x1087d
movl $0x1bc, %ecx            # imm = 0x1BC
callq 0x7ad0
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
je 0x4b81
movq 0x30(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
leaq 0x1b11(%rip), %rdx      # 0x6630
callq 0x62e0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4b4b
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x6150
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x8(%rsp)
jmp 0x4b71
movl $0x80050000, %edi       # imm = 0x80050000
leaq 0xc0ff(%rip), %rsi      # 0x10c56
leaq 0xbd1f(%rip), %rdx      # 0x1087d
movl $0x1c0, %ecx            # imm = 0x1C0
callq 0x3940
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirfilecache.c
// Function: sir_remfile
bool _sir_remfile(sirfileid id) {
    (void)_sir_seterror(_SIR_E_NOERROR);

    if (!_sir_sanity() || !_sir_validfileid(id))
        return false;

    _SIR_LOCK_SECTION(sirfcache, sfc, SIRMI_FILECACHE, false);
    bool retval = _sir_fcache_rem(sfc, id);
    _SIR_UNLOCK_SECTION(SIRMI_FILECACHE);

    return retval;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl $0x80010000, %edi       # imm = 0x80010000
leaq 0xbcf8(%rip), %rsi      # 0x1089c
leaq 0xbcd2(%rip), %rdx      # 0x1087d
movl $0x46, %ecx
callq 0x3940
callq 0x9d10
testb $0x1, %al
jne 0x4bc0
jmp 0x4bcd
movl 0x10(%rsp), %edi
callq 0x4a70
testb $0x1, %al
jne 0x4bd4
movb $0x0, 0x17(%rsp)
jmp 0x4c39
movl $0x1, %edi
callq 0x9650
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4c0f
movl $0x800f0000, %edi       # imm = 0x800F0000
leaq 0xbca5(%rip), %rsi      # 0x1089c
leaq 0xbc7f(%rip), %rdx      # 0x1087d
movl $0x4b, %ecx
callq 0x3940
movb $0x0, 0x17(%rsp)
jmp 0x4c39
jmp 0x4c11
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x4c50
andb $0x1, %al
movb %al, 0x7(%rsp)
movl $0x1, %edi
callq 0x9aa0
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirfilecache.c
// Function: sir_fcache_rem
bool _sir_fcache_rem(sirfcache* sfc, sirfileid id) {
    bool retval = _sir_validptr(sfc) && _sir_validfileid(id);

    if (retval) {
        bool found = false;
        for (size_t n = 0; n < sfc->count; n++) {
            SIR_ASSERT(_sirfile_validate(sfc->files[n]));

            if (sfc->files[n]->id == id) {
                _sir_selflog("removing file (path: '%s', id: %"PRIx32"); count = %zu",
                    sfc->files[n]->path, sfc->files[n]->id, sfc->count - 1);

                _sirfile_destroy(&sfc->files[n]);
                _sir_fcache_shift(sfc, n);

                sfc->count--;
                found = true;
                break;
            }
        }

        if (!found)
            retval = _sir_seterror(_SIR_E_NOITEM);
    }

    return retval;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0xbffb(%rip), %rdx      # 0x10c69
leaq 0xbc08(%rip), %rcx      # 0x1087d
movl $0x1c7, %r8d            # imm = 0x1C7
callq 0x5200
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4c8f
jmp 0x4c9c
movl 0x1c(%rsp), %edi
callq 0x4a70
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x1b(%rsp)
testb $0x1, 0x1b(%rsp)
je 0x4db5
movb $0x0, 0x1a(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x80(%rcx), %rax
jae 0x4d89
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x18(%rax), %eax
cmpl 0x1c(%rsp), %eax
jne 0x4d74
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x18(%rax), %edx
movq 0x20(%rsp), %rax
movq 0x80(%rax), %rcx
subq $0x1, %rcx
leaq 0xbf4f(%rip), %rdi      # 0x10c79
movb $0x0, %al
callq 0x5ff0
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x51c0
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x6660
movq 0x20(%rsp), %rax
movq 0x80(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x80(%rax)
movb $0x1, 0x1a(%rsp)
jmp 0x4d89
jmp 0x4d76
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4cbf
testb $0x1, 0x1a(%rsp)
jne 0x4db3
movl $0x80050000, %edi       # imm = 0x80050000
leaq 0xbecd(%rip), %rsi      # 0x10c69
leaq 0xbada(%rip), %rdx      # 0x1087d
movl $0x1dc, %ecx            # imm = 0x1DC
callq 0x3940
andb $0x1, %al
movb %al, 0x1b(%rsp)
jmp 0x4db5
movb 0x1b(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirfilecache.c
// Function: sirfile_create
sirfile* _sirfile_create(const char* path, sir_levels levels, sir_options opts) {
    if (!_sir_validstr(path) || !_sir_validlevels(levels) || !_sir_validopts(opts))
        return NULL;

    sirfile* sf = (sirfile*)calloc(1, sizeof(sirfile));
    if (!sf) {
        (void)_sir_handleerr(errno);
        return NULL;
    }

    sf->path = strndup(path, strnlen(path, SIR_MAXPATH));
    if (!sf->path) {
        (void)_sir_handleerr(errno);
        _sir_safefree(&sf);
        return NULL;
    }

    sf->levels = levels;
    sf->opts   = opts;

    if (!_sirfile_open(sf) || !_sirfile_validate(sf)) {
        _sirfile_destroy(&sf);
        return NULL;
    }

    return sf;
}

// Assembly:
subq $0x28, %rsp
movw %si, %ax
movq %rdi, 0x18(%rsp)
movw %ax, 0x16(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0xbac3(%rip), %rdx      # 0x108a9
leaq 0xba90(%rip), %rcx      # 0x1087d
movl $0x53, %r8d
callq 0x4f70
testb $0x1, %al
jne 0x4dfe
jmp 0x4e41
leaq 0xbaa4(%rip), %rsi      # 0x108a9
leaq 0xba71(%rip), %rdx      # 0x1087d
movl $0x53, %ecx
movzwl 0x16(%rsp), %edi
callq 0x7da0
testb $0x1, %al
jne 0x4e21
jmp 0x4e41
movl 0x10(%rsp), %edi
leaq 0xba7d(%rip), %rsi      # 0x108a9
leaq 0xba4a(%rip), %rdx      # 0x1087d
movl $0x53, %ecx
callq 0x7ed0
testb $0x1, %al
jne 0x4e4f
movq $0x0, 0x20(%rsp)
jmp 0x4f5d
movl $0x1, %edi
movl $0x20, %esi
callq 0x2230
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4e98
callq 0x2070
movl (%rax), %edi
leaq 0xba30(%rip), %rsi      # 0x108a9
leaq 0xb9fd(%rip), %rdx      # 0x1087d
movl $0x58, %ecx
callq 0x3c00
movq $0x0, 0x20(%rsp)
jmp 0x4f5d
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x21d0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x2210
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x4f06
callq 0x2070
movl (%rax), %edi
leaq 0xb9c9(%rip), %rsi      # 0x108a9
leaq 0xb996(%rip), %rdx      # 0x1087d
movl $0x5e, %ecx
callq 0x3c00
leaq 0x8(%rsp), %rdi
callq 0x7910
movq $0x0, 0x20(%rsp)
jmp 0x4f5d
movw 0x16(%rsp), %cx
movq 0x8(%rsp), %rax
movw %cx, 0x8(%rax)
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x8(%rsp), %rdi
callq 0x4ff0
testb $0x1, %al
jne 0x4f30
jmp 0x4f3e
movq 0x8(%rsp), %rdi
callq 0x5100
testb $0x1, %al
jne 0x4f53
leaq 0x8(%rsp), %rdi
callq 0x51c0
movq $0x0, 0x20(%rsp)
jmp 0x4f5d
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirfilecache.c
// Function: sirfile_open
bool _sirfile_open(sirfile* sf) {
    bool retval = _sir_validptr(sf) && _sir_validstr(sf->path);

    if (retval) {
        FILE* f  = NULL;
        retval = _sir_openfile(&f, sf->path, SIR_FOPENMODE, SIR_PATH_REL_TO_CWD);
        if (retval && NULL != f) {
            _sirfile_close(sf);

            sf->f  = f;
            sf->id = FNV32_1a((const uint8_t*)sf->path, strnlen(sf->path, SIR_MAXPATH));
        }
    }

    return retval;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0xb8af(%rip), %rdx      # 0x108b9
leaq 0xb86c(%rip), %rcx      # 0x1087d
movl $0x6f, %r8d
callq 0x5200
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x502b
jmp 0x5055
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
leaq 0xb87a(%rip), %rdx      # 0x108b9
leaq 0xb837(%rip), %rcx      # 0x1087d
movl $0x6f, %r8d
callq 0x4f70
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
je 0x50f5
movq $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xbefe(%rip), %rdx      # 0x10f85
movl $0x1, %ecx
callq 0x7110
andb $0x1, %al
movb %al, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
je 0x50f3
xorl %eax, %eax
cmpq 0x10(%rsp), %rax
je 0x50f3
movq 0x20(%rsp), %rdi
callq 0x5270
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x21d0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x52b0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x18(%rax)
jmp 0x50f5
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq