LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_hist.c
// Function: cf_histogram_create
cf_histogram * 
cf_histogram_create(char *name)
{
	cf_histogram * h = (cf_histogram*)malloc(sizeof(cf_histogram));
	if (!h)	return(0);
	if (strlen(name) >= sizeof(h->name)-1) { free(h); return(0); }
	strcpy(h->name, name);
	h->n_counts = 0;
	memset((void*)&h->count, 0, sizeof(h->count));
	return(h);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x248, %edi            # imm = 0x248
callq 0x6720
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x16479
movq $0x0, 0x10(%rsp)
jmp 0x164d4
movq 0x8(%rsp), %rdi
callq 0x6280
cmpq $0x3f, %rax
jb 0x1649d
movq (%rsp), %rdi
callq 0x6070
movq $0x0, 0x10(%rsp)
jmp 0x164d4
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x60e0
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rdi
addq $0x48, %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x63f0
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_hist.c
// Function: cf_histogram_insert_data_point
void 
cf_histogram_insert_data_point( cf_histogram *h, uint64_t start)
{
    cf_atomic_int_incr(&h->n_counts);
	
    uint64_t end = cf_getms(); 
    uint64_t delta = end - start;
	
	int index = cf_bits_find_last_set_64(delta);
	if (index < 0) index = 0;   
	if (start > end)
	{
	    // Need to investigate why in some cases start is a couple of ms greater than end
		// Could it be rounding error (usually the difference is 1 but sometimes I have seen 2
		index = 0;
	}   
       
	cf_atomic_int_incr( &h->count[ index ] );
	
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
addq $0x40, %rdi
movl $0x1, %esi
callq 0x169b0
callq 0x16a40
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
subq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x61a0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x16977
movl $0x0, 0x4(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jbe 0x1698b
movl $0x0, 0x4(%rsp)
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
movslq 0x4(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x169b0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_service.c
// Function: cf_process_privsep
void
cf_process_privsep(uid_t uid, gid_t gid)
{
    if ((0 != getuid() || ((uid == getuid()) && (gid == getgid()))))
        return;

    /* Drop all auxiliary groups */
    if (0 > setgroups(0, (const gid_t *)0)){
        cf_error("Could not set groups: %s", strerror(errno));
//        cf_crash(CF_MISC, CF_GLOBAL, CF_CRITICAL, "setgroups: %s", cf_strerror(errno));
        exit(-1);
    }

    /* Change privileges */
    if (0 > setgid(gid)){
    	cf_error("Could not set gid: %s", strerror(errno));
//        cf_crash(CF_MISC, CF_GLOBAL, CF_CRITICAL, "setgid: %s", cf_strerror(errno));
        exit(-2);
    }
    if (0 > setuid(uid)){
    	cf_error("Could not set uid: %s", strerror(errno));
//        cf_crash(CF_MISC, CF_GLOBAL, CF_CRITICAL, "setuid: %s", cf_strerror(errno));
        exit(-2);
    }

    return;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
callq 0x62b0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x18c37
movl 0x24(%rsp), %eax
movl %eax, 0x1c(%rsp)
callq 0x62b0
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jne 0x18c3c
movl 0x20(%rsp), %eax
movl %eax, 0x18(%rsp)
callq 0x6670
movl %eax, %ecx
movl 0x18(%rsp), %eax
cmpl %ecx, %eax
jne 0x18c3c
jmp 0x18d4d
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x6480
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x18c99
movq 0xa371(%rip), %rax      # 0x22fc8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x18c8f
movq 0xa33a(%rip), %rax      # 0x22fa0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x60a0
movl (%rax), %edi
callq 0x6be0
movq 0x10(%rsp), %rcx
movq %rax, %rdx
xorl %edi, %edi
leaq 0x5795(%rip), %rsi      # 0x1e420
movb $0x0, %al
callq *%rcx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x6ae0
movl 0x20(%rsp), %edi
callq 0x6950
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x18cf3
movq 0xa317(%rip), %rax      # 0x22fc8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x18ce9
movq 0xa2e0(%rip), %rax      # 0x22fa0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x60a0
movl (%rax), %edi
callq 0x6be0
movq 0x8(%rsp), %rcx
movq %rax, %rdx
xorl %edi, %edi
leaq 0x5754(%rip), %rsi      # 0x1e439
movb $0x0, %al
callq *%rcx
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x6ae0
movl 0x24(%rsp), %edi
callq 0x6b50
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x18d4b
movq 0xa2bd(%rip), %rax      # 0x22fc8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x18d41
movq 0xa286(%rip), %rax      # 0x22fa0
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x60a0
movl (%rax), %edi
callq 0x6be0
movq (%rsp), %rcx
movq %rax, %rdx
xorl %edi, %edi
leaq 0x5712(%rip), %rsi      # 0x1e44f
movb $0x0, %al
callq *%rcx
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x6ae0
jmp 0x18d4d
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_08/argv.c
// Function: main
int main(int argc, char *argv[])
{
	int n;

	for (n = 0; n < argc; n++)
		printf("argv[%d]=\"%s\"\n", n, argv[n]);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x118d
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0xe89(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x115d
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c0stya[P]fslib/src/fsshort.c
// Function: main
int main(int argc, char * argv[]) {
    struct _fst * fst = fst_create(); 
    struct _fst * path = fst_create(); 

    const char * ifilename = NULL; 
    const char * ofilename = NULL;

    FILE * fin = stdin;
    FILE * fout = stdout;

    if (argc > 1)
        ifilename = argv[1];
    if (argc > 2)
        ofilename = argv[2];
    
    if (ifilename) {
        if (( fin = fopen(ifilename, "rb")) == NULL ) {
            fprintf(stderr, "Error opening file: %s", ifilename);
            exit(EXIT_FAILURE);
        }
    }

    if (ofilename) {
        if (( fout = fopen(ofilename, "w")) == NULL ) {
            fprintf(stderr, "Error opening file: %s", ofilename);
            exit(EXIT_FAILURE);
        }
    }

    fst_read(fst, fin);
    fst_shortest(fst, path);
    fst_write(path, fout);

    fst_remove(fst);
    fst_remove(path);
    
    if (fin != stdout) {
        fclose(fin);
    }
    if (fout != stdout) {
        fclose(fout);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, %al
callq 0x2740
movq %rax, -0x18(%rbp)
movb $0x0, %al
callq 0x2740
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq 0x40b5(%rip), %rax      # 0xafd8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq 0x409f(%rip), %rax      # 0xafd0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x6f4a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x2, -0x8(%rbp)
jle 0x6f5c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6fa5
movq -0x28(%rbp), %rdi
leaq 0x117b(%rip), %rsi      # 0x80e9
callq 0x1150
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x6fa3
movq 0x4074(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1140(%rip), %rsi      # 0x80d2
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x1180
jmp 0x6fa5
cmpq $0x0, -0x30(%rbp)
je 0x6fee
movq -0x30(%rbp), %rdi
leaq 0x17c8(%rip), %rsi      # 0x877f
callq 0x1150
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x6fec
movq 0x402b(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
leaq 0x10f7(%rip), %rsi      # 0x80d2
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x1180
jmp 0x6fee
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2bc0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4f60
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x2a80
movq -0x18(%rbp), %rdi
callq 0x2950
movq -0x20(%rbp), %rdi
callq 0x2950
movq -0x38(%rbp), %rax
movq 0x3f9e(%rip), %rcx      # 0xafd0
cmpq (%rcx), %rax
je 0x7040
movq -0x38(%rbp), %rdi
callq 0x1080
movq -0x40(%rbp), %rax
movq 0x3f85(%rip), %rcx      # 0xafd0
cmpq (%rcx), %rax
je 0x7059
movq -0x40(%rbp), %rdi
callq 0x1080
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_module
static void _asm_module(
	ASMGeneratorGas32Context *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_MODULE);

	_OUT_CSTR(ctx, RSTR_CSTR(ctx->global));

	for (int i = 0; i < node->nchilds; i++) {
		_asm_module_item(ctx, node->childs[i]);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf5a9
jmp 0xf5c8
leaq 0x70bb1(%rip), %rdi     # 0x80161
leaq 0x66341(%rip), %rsi     # 0x758f8
movl $0x2ca9, %edx           # imm = 0x2CA9
leaq 0x66540(%rip), %rcx     # 0x75b03
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0xf5d1
jmp 0xf5f0
leaq 0x66f84(%rip), %rdi     # 0x7655c
leaq 0x66319(%rip), %rsi     # 0x758f8
movl $0x2caa, %edx           # imm = 0x2CAA
leaq 0x66518(%rip), %rcx     # 0x75b03
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jne 0xf5fe
jmp 0xf61d
leaq 0x6653c(%rip), %rdi     # 0x75b41
leaq 0x662ec(%rip), %rsi     # 0x758f8
movl $0x2cab, %edx           # imm = 0x2CAB
leaq 0x664eb(%rip), %rcx     # 0x75b03
callq 0x30a0
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0xf648
leaq 0x668fd(%rip), %rax     # 0x75f3f
movq %rax, -0x28(%rbp)
jmp 0xf658
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3080
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0xf6c0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0xf689
leaq 0x668bc(%rip), %rax     # 0x75f3f
movq %rax, -0x30(%rbp)
jmp 0xf699
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x30d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf624
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0xf6f7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xfae0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xf6c7
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_module_item
static void _asm_module_item(
	ASMGeneratorGas32Context *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	ctx->func_symbol = NULL;

	switch (node->type) {
		case BE_NODE_VAR: {
			_asm_var(ctx, node);
			break;
		}
		case BE_NODE_STRUCT: {
			// ...
			break;
		}
		case BE_NODE_FUNC: {
			_asm_func(ctx, node);
			break;
		}
		default: {
			assert(0);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xfaf9
jmp 0xfb18
leaq 0x70661(%rip), %rdi     # 0x80161
leaq 0x65df1(%rip), %rsi     # 0x758f8
movl $0x2c8c, %edx           # imm = 0x2C8C
leaq 0x6604b(%rip), %rcx     # 0x75b5e
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0xfb21
jmp 0xfb40
leaq 0x66a34(%rip), %rdi     # 0x7655c
leaq 0x65dc9(%rip), %rsi     # 0x758f8
movl $0x2c8d, %edx           # imm = 0x2C8D
leaq 0x66023(%rip), %rcx     # 0x75b5e
callq 0x30a0
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0xa00, %eax            # imm = 0xA00
je 0xfb87
jmp 0xfb5e
movl -0x14(%rbp), %eax
subl $0xc00, %eax            # imm = 0xC00
je 0xfb76
jmp 0xfb6a
movl -0x14(%rbp), %eax
subl $0xd00, %eax            # imm = 0xD00
je 0xfb85
jmp 0xfb96
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfbc0
jmp 0xfbb5
jmp 0xfbb5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10570
jmp 0xfbb5
leaq 0x638bd(%rip), %rdi     # 0x7345a
leaq 0x65d54(%rip), %rsi     # 0x758f8
movl $0x2c9f, %edx           # imm = 0x2C9F
leaq 0x65fae(%rip), %rcx     # 0x75b5e
callq 0x30a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_global_var_initializer
static void _asm_global_var_initializer(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	ParserASTNode *node_constexpr,
	ParserASTNode *node_type
) {
	assert(ctx);
	assert(rstr);
	assert(node_type);

	if (node_constexpr != NULL) {
		_asm_constexpr_initializer(ctx, rstr, node_constexpr);
	} else {
		_asm_zero_initializer(ctx, rstr, node_type);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10d51
jmp 0x10d70
leaq 0x6f409(%rip), %rdi     # 0x80161
leaq 0x64b99(%rip), %rsi     # 0x758f8
movl $0xd30, %edx            # imm = 0xD30
leaq 0x64fdc(%rip), %rcx     # 0x75d47
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x10d79
jmp 0x10d98
leaq 0x62d8d(%rip), %rdi     # 0x73b0d
leaq 0x64b71(%rip), %rsi     # 0x758f8
movl $0xd31, %edx            # imm = 0xD31
leaq 0x64fb4(%rip), %rcx     # 0x75d47
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x10da1
jmp 0x10dc0
leaq 0x74496(%rip), %rdi     # 0x8523e
leaq 0x64b49(%rip), %rsi     # 0x758f8
movl $0xd32, %edx            # imm = 0xD32
leaq 0x64f8c(%rip), %rcx     # 0x75d47
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x10dda
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10ee0
jmp 0x10deb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10fb0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_memref_base_disp
static void _asm_inst_memref_base_disp(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	const char *base,
	const char *disp
) {
	assert(ctx);
	assert(rstr);
	assert(base);
	assert(disp);

	rstr_appendf(
		rstr,
		"%s(%s)",
		disp,
		base
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10e21
jmp 0x10e40
leaq 0x6f339(%rip), %rdi     # 0x80161
leaq 0x64ac9(%rip), %rsi     # 0x758f8
movl $0x1db, %edx            # imm = 0x1DB
leaq 0x65190(%rip), %rcx     # 0x75fcb
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x10e49
jmp 0x10e68
leaq 0x62cbd(%rip), %rdi     # 0x73b0d
leaq 0x64aa1(%rip), %rsi     # 0x758f8
movl $0x1dc, %edx            # imm = 0x1DC
leaq 0x65168(%rip), %rcx     # 0x75fcb
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x10e71
jmp 0x10e90
leaq 0x651be(%rip), %rdi     # 0x76036
leaq 0x64a79(%rip), %rsi     # 0x758f8
movl $0x1dd, %edx            # imm = 0x1DD
leaq 0x65140(%rip), %rcx     # 0x75fcb
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x10e99
jmp 0x10eb8
leaq 0x6519b(%rip), %rdi     # 0x7603b
leaq 0x64a51(%rip), %rsi     # 0x758f8
movl $0x1de, %edx            # imm = 0x1DE
leaq 0x65118(%rip), %rcx     # 0x75fcb
callq 0x30a0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x65175(%rip), %rsi     # 0x76040
movb $0x0, %al
callq 0x94d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_constexpr_initializer
static void _asm_constexpr_initializer(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	ParserASTNode *node_constexpr
) {
	assert(ctx);
	assert(rstr);
	assert(node_constexpr);
	assert(BE_EXPR_AST_NODE_GET_CONSTANT(node_constexpr));

	_asm_constexpr(ctx, rstr, node_constexpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10efd
jmp 0x10f1c
leaq 0x6f25d(%rip), %rdi     # 0x80161
leaq 0x649ed(%rip), %rsi     # 0x758f8
movl $0xcf7, %edx            # imm = 0xCF7
leaq 0x64ea2(%rip), %rcx     # 0x75db9
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x10f25
jmp 0x10f44
leaq 0x62be1(%rip), %rdi     # 0x73b0d
leaq 0x649c5(%rip), %rsi     # 0x758f8
movl $0xcf8, %edx            # imm = 0xCF8
leaq 0x64e7a(%rip), %rcx     # 0x75db9
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x10f4d
jmp 0x10f6c
leaq 0x64ec5(%rip), %rdi     # 0x75e19
leaq 0x6499d(%rip), %rsi     # 0x758f8
movl $0xcf9, %edx            # imm = 0xCF9
leaq 0x64e52(%rip), %rcx     # 0x75db9
callq 0x30a0
movq -0x18(%rbp), %rax
testb $0x1, 0x70(%rax)
je 0x10f78
jmp 0x10f97
leaq 0x64ea9(%rip), %rdi     # 0x75e28
leaq 0x64972(%rip), %rsi     # 0x758f8
movl $0xcfa, %edx            # imm = 0xCFA
leaq 0x64e27(%rip), %rcx     # 0x75db9
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x110e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_zero_initializer
static void _asm_zero_initializer(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	ParserASTNode *node_type
) {
	assert(ctx);
	assert(rstr);
	assert(node_type);

	switch (node_type->type) {
		case BE_NODE_TYPE_CHAR:
		case BE_NODE_TYPE_INT8:
		case BE_NODE_TYPE_UINT8:
		case BE_NODE_TYPE_INT16:
		case BE_NODE_TYPE_UINT16:
		case BE_NODE_TYPE_INT32:
		case BE_NODE_TYPE_UINT32:
		case BE_NODE_TYPE_INT64:
		case BE_NODE_TYPE_UINT64: {
			rstr_append_with_cstr(rstr, "0");
			break;
		}
		case BE_NODE_TYPE_FLOAT:
		case BE_NODE_TYPE_DOUBLE: {
			rstr_append_with_cstr(rstr, "0.0");
			break;
		}
		case BE_NODE_TYPE_STRUCT:
		case BE_NODE_TYPE_ARRAY: {
			assert(0);
			break;
		}
		case BE_NODE_TYPE_POINTER: {
			rstr_append_with_cstr(rstr, "0");
			break;
		}
		default: {
			assert(0);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10fcd
jmp 0x10fec
leaq 0x6f18d(%rip), %rdi     # 0x80161
leaq 0x6491d(%rip), %rsi     # 0x758f8
movl $0xd04, %edx            # imm = 0xD04
leaq 0x64f85(%rip), %rcx     # 0x75f6c
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x10ff5
jmp 0x11014
leaq 0x62b11(%rip), %rdi     # 0x73b0d
leaq 0x648f5(%rip), %rsi     # 0x758f8
movl $0xd05, %edx            # imm = 0xD05
leaq 0x64f5d(%rip), %rcx     # 0x75f6c
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x1101d
jmp 0x1103c
leaq 0x7421a(%rip), %rdi     # 0x8523e
leaq 0x648cd(%rip), %rsi     # 0x758f8
movl $0xd06, %edx            # imm = 0xD06
leaq 0x64f35(%rip), %rcx     # 0x75f6c
callq 0x30a0
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $0xfffffc00, %eax       # imm = 0xFFFFFC00
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x40, %eax
ja 0x110bb
movq -0x20(%rbp), %rax
leaq 0x64333(%rip), %rcx     # 0x75390
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
leaq 0x623e9(%rip), %rsi     # 0x7345a
callq 0x8d70
jmp 0x110da
movq -0x10(%rbp), %rdi
leaq 0x64f44(%rip), %rsi     # 0x75fc7
callq 0x8d70
jmp 0x110da
leaq 0x623c9(%rip), %rdi     # 0x7345a
leaq 0x64860(%rip), %rsi     # 0x758f8
movl $0xd1c, %edx            # imm = 0xD1C
leaq 0x64ec8(%rip), %rcx     # 0x75f6c
callq 0x30a0
movq -0x10(%rbp), %rdi
leaq 0x623a6(%rip), %rsi     # 0x7345a
callq 0x8d70
jmp 0x110da
leaq 0x62398(%rip), %rdi     # 0x7345a
leaq 0x6482f(%rip), %rsi     # 0x758f8
movl $0xd24, %edx            # imm = 0xD24
leaq 0x64e97(%rip), %rcx     # 0x75f6c
callq 0x30a0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_stats_block
static void _asm_stats_block(
	ASMGeneratorGas32Context *ctx,
	ParserASTNode *node_stats_block
) {
	assert(ctx);
	assert(node_stats_block);
	assert(node_stats_block->type == BE_NODE_STATS_BLOCK);

	for (int i = 0; i < node_stats_block->nchilds; i++) {
		ParserASTNode *node_stat = node_stats_block->childs[i];
		_asm_stat(ctx, node_stat);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x117f9
jmp 0x11818
leaq 0x6e961(%rip), %rdi     # 0x80161
leaq 0x640f1(%rip), %rsi     # 0x758f8
movl $0x2ba1, %edx           # imm = 0x2BA1
leaq 0x64a3d(%rip), %rcx     # 0x76250
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x11821
jmp 0x11840
leaq 0x64a6b(%rip), %rdi     # 0x76293
leaq 0x640c9(%rip), %rsi     # 0x758f8
movl $0x2ba2, %edx           # imm = 0x2BA2
leaq 0x64a15(%rip), %rcx     # 0x76250
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb00, (%rax)          # imm = 0xB00
jne 0x1184e
jmp 0x1186d
leaq 0x64a4f(%rip), %rdi     # 0x762a4
leaq 0x6409c(%rip), %rsi     # 0x758f8
movl $0x2ba3, %edx           # imm = 0x2BA3
leaq 0x649e8(%rip), %rcx     # 0x76250
callq 0x30a0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x118ac
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11a30
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11874
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: _out_label
static void __out_label(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	const char *prefix,
	const char *label
) {
	assert(ctx);
	assert(rstr);
	assert(label);

	ParserSymbol *func_symbol = ctx->func_symbol;
	assert(func_symbol);
	ParserASTNode *func_name_node = BE_FUNC_SYMBOL_GET_FUNC_NAME_NODE(func_symbol);
	assert(func_name_node);

	rstr_append_with_cstr(rstr, "_LABEL.");
	rstr_append_with_raw(rstr, func_name_node->token->content, func_name_node->token->len);
	rstr_append_with_char(rstr, '.');
	if (prefix != NULL) {
		rstr_appendf(rstr, "%s.", prefix);
	}
	rstr_append_with_cstr(rstr, label);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x118e1
jmp 0x11900
leaq 0x6e879(%rip), %rdi     # 0x80161
leaq 0x64009(%rip), %rsi     # 0x758f8
movl $0x259, %edx            # imm = 0x259
leaq 0x68a7a(%rip), %rcx     # 0x7a375
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x11909
jmp 0x11928
leaq 0x621fd(%rip), %rdi     # 0x73b0d
leaq 0x63fe1(%rip), %rsi     # 0x758f8
movl $0x25a, %edx            # imm = 0x25A
leaq 0x68a52(%rip), %rcx     # 0x7a375
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x11931
jmp 0x11950
leaq 0x68a99(%rip), %rdi     # 0x7a3d1
leaq 0x63fb9(%rip), %rsi     # 0x758f8
movl $0x25b, %edx            # imm = 0x25B
leaq 0x68a2a(%rip), %rcx     # 0x7a375
callq 0x30a0
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x11965
jmp 0x11984
leaq 0x64737(%rip), %rdi     # 0x760a3
leaq 0x63f85(%rip), %rsi     # 0x758f8
movl $0x25e, %edx            # imm = 0x25E
leaq 0x689f6(%rip), %rcx     # 0x7a375
callq 0x30a0
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x11999
jmp 0x119b8
leaq 0x64bb2(%rip), %rdi     # 0x76552
leaq 0x63f51(%rip), %rsi     # 0x758f8
movl $0x260, %edx            # imm = 0x260
leaq 0x689c2(%rip), %rcx     # 0x7a375
callq 0x30a0
movq -0x10(%rbp), %rdi
leaq 0x68a14(%rip), %rsi     # 0x7a3d7
callq 0x8d70
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %edx
callq 0x8f90
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x8ea0
cmpq $0x0, -0x18(%rbp)
je 0x11a13
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x689d3(%rip), %rsi     # 0x7a3df
movb $0x0, %al
callq 0x94d0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8d70
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_stat_var
static void _asm_stat_var(
	ASMGeneratorGas32Context *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_VAR);

	_asm_var(ctx, node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11e89
jmp 0x11ea8
leaq 0x6e2d1(%rip), %rdi     # 0x80161
leaq 0x63a61(%rip), %rsi     # 0x758f8
movl $0x108c, %edx           # imm = 0x108C
leaq 0x64475(%rip), %rcx     # 0x76318
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x11eb1
jmp 0x11ed0
leaq 0x646a4(%rip), %rdi     # 0x7655c
leaq 0x63a39(%rip), %rsi     # 0x758f8
movl $0x108d, %edx           # imm = 0x108D
leaq 0x6444d(%rip), %rcx     # 0x76318
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xc00, (%rax)          # imm = 0xC00
jne 0x11ede
jmp 0x11efd
leaq 0x71029(%rip), %rdi     # 0x82f0e
leaq 0x63a0c(%rip), %rsi     # 0x758f8
movl $0x108e, %edx           # imm = 0x108E
leaq 0x64420(%rip), %rcx     # 0x76318
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfbc0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_stat_asm
static void _asm_stat_asm(
	ASMGeneratorGas32Context *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_ASM);
	assert(node->nchilds == 1);

	ParserASTNode *node_asm_code = node->childs[0];
	assert(node_asm_code->type == BE_NODE_LITERAL_STRING);

	_out_literal_string(ctx, ctx->body, node_asm_code);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12399
jmp 0x123b8
leaq 0x6ddc1(%rip), %rdi     # 0x80161
leaq 0x63551(%rip), %rsi     # 0x758f8
movl $0x1135, %edx           # imm = 0x1135
leaq 0x647f2(%rip), %rcx     # 0x76ba5
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x123c1
jmp 0x123e0
leaq 0x64194(%rip), %rdi     # 0x7655c
leaq 0x63529(%rip), %rsi     # 0x758f8
movl $0x1136, %edx           # imm = 0x1136
leaq 0x647ca(%rip), %rcx     # 0x76ba5
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb40, (%rax)          # imm = 0xB40
jne 0x123ee
jmp 0x1240d
leaq 0x647f0(%rip), %rdi     # 0x76be5
leaq 0x634fc(%rip), %rsi     # 0x758f8
movl $0x1137, %edx           # imm = 0x1137
leaq 0x6479d(%rip), %rcx     # 0x76ba5
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x12419
jmp 0x12438
leaq 0x64fee(%rip), %rdi     # 0x7740e
leaq 0x634d1(%rip), %rsi     # 0x758f8
movl $0x1138, %edx           # imm = 0x1138
leaq 0x64772(%rip), %rcx     # 0x76ba5
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x303, (%rax)          # imm = 0x303
jne 0x12455
jmp 0x12474
leaq 0x647a8(%rip), %rdi     # 0x76c04
leaq 0x63495(%rip), %rsi     # 0x758f8
movl $0x113b, %edx           # imm = 0x113B
leaq 0x64736(%rip), %rcx     # 0x76ba5
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x21ff0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_stat_label
static void _asm_stat_label(
	ASMGeneratorGas32Context *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_LABEL);
	assert(node->nchilds == 1);

	ParserASTNode *node_id = node->childs[0];
	assert(node_id->type == BE_NODE_IDENTIFIER);

	_out_label(ctx, ctx->body, NULL, node_id);
	rstr_append_with_cstr(ctx->body, ":\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12b39
jmp 0x12b58
leaq 0x6d621(%rip), %rdi     # 0x80161
leaq 0x62db1(%rip), %rsi     # 0x758f8
movl $0x11b8, %edx           # imm = 0x11B8
leaq 0x643ec(%rip), %rcx     # 0x76f3f
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x12b61
jmp 0x12b80
leaq 0x639f4(%rip), %rdi     # 0x7655c
leaq 0x62d89(%rip), %rsi     # 0x758f8
movl $0x11b9, %edx           # imm = 0x11B9
leaq 0x643c4(%rip), %rcx     # 0x76f3f
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb30, (%rax)          # imm = 0xB30
jne 0x12b8e
jmp 0x12bad
leaq 0x643ec(%rip), %rdi     # 0x76f81
leaq 0x62d5c(%rip), %rsi     # 0x758f8
movl $0x11ba, %edx           # imm = 0x11BA
leaq 0x64397(%rip), %rcx     # 0x76f3f
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x12bb9
jmp 0x12bd8
leaq 0x6484e(%rip), %rdi     # 0x7740e
leaq 0x62d31(%rip), %rsi     # 0x758f8
movl $0x11bb, %edx           # imm = 0x11BB
leaq 0x6436c(%rip), %rcx     # 0x76f3f
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x12bf5
jmp 0x12c14
leaq 0x643a6(%rip), %rdi     # 0x76fa2
leaq 0x62cf5(%rip), %rsi     # 0x758f8
movl $0x11be, %edx           # imm = 0x11BE
leaq 0x64330(%rip), %rcx     # 0x76f3f
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x224b0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0x635e4(%rip), %rsi     # 0x76220
callq 0x8d70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_stat_br
static void _asm_stat_br(
	ASMGeneratorGas32Context *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_BR);
	assert(node->nchilds == 1);

	ParserASTNode *node_id = node->childs[0];
	assert(node_id->type == BE_NODE_IDENTIFIER);

	ResizableString rstr_id;
	rstr_init(&rstr_id);
	_out_label(ctx, &rstr_id, NULL, node_id);

	_asm_inst_jmp_x(ctx, ctx->body, RSTR_CSTR(&rstr_id));

	rstr_free(&rstr_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12c69
jmp 0x12c88
leaq 0x6d4f1(%rip), %rdi     # 0x80161
leaq 0x62c81(%rip), %rsi     # 0x758f8
movl $0x11c8, %edx           # imm = 0x11C8
leaq 0x643a9(%rip), %rcx     # 0x7702c
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x12c91
jmp 0x12cb0
leaq 0x638c4(%rip), %rdi     # 0x7655c
leaq 0x62c59(%rip), %rsi     # 0x758f8
movl $0x11c9, %edx           # imm = 0x11C9
leaq 0x64381(%rip), %rcx     # 0x7702c
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb10, (%rax)          # imm = 0xB10
jne 0x12cbe
jmp 0x12cdd
leaq 0x643a6(%rip), %rdi     # 0x7706b
leaq 0x62c2c(%rip), %rsi     # 0x758f8
movl $0x11ca, %edx           # imm = 0x11CA
leaq 0x64354(%rip), %rcx     # 0x7702c
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x12ce9
jmp 0x12d08
leaq 0x6471e(%rip), %rdi     # 0x7740e
leaq 0x62c01(%rip), %rsi     # 0x758f8
movl $0x11cb, %edx           # imm = 0x11CB
leaq 0x64329(%rip), %rcx     # 0x7702c
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x12d25
jmp 0x12d44
leaq 0x64276(%rip), %rdi     # 0x76fa2
leaq 0x62bc5(%rip), %rsi     # 0x758f8
movl $0x11ce, %edx           # imm = 0x11CE
leaq 0x642ed(%rip), %rcx     # 0x7702c
callq 0x30a0
leaq -0x28(%rbp), %rdi
callq 0x8c90
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x224b0
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x12d8a
leaq 0x631bb(%rip), %rax     # 0x75f3f
movq %rax, -0x40(%rbp)
jmp 0x12d92
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
callq 0x225c0
leaq -0x28(%rbp), %rdi
callq 0x9310
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_stat_return
static void _asm_stat_return(
	ASMGeneratorGas32Context *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_RETURN);
	assert(node->nchilds == 0
			|| node->nchilds == 1);

	if (node->nchilds == 1) {
		ParserASTNode *node_ret_val = node->childs[0];
		_move_id_or_constexpr_to_reg(
			ctx,
			_ASM_REG_AX,
			_ASM_REG_DX,
			node_ret_val
		);
	}

	ResizableString rstr_ret;
	rstr_init(&rstr_ret);
	__out_label(
		ctx,
		&rstr_ret,
		_ASM_FUNC_RETURN_LABEL_PREFIX,
		_ASM_FUNC_RETURN_LABEL
	);
	_asm_inst_jmp_x(ctx, ctx->body, RSTR_CSTR(&rstr_ret));
	rstr_free(&rstr_ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13299
jmp 0x132b8
leaq 0x6cec1(%rip), %rdi     # 0x80161
leaq 0x62651(%rip), %rsi     # 0x758f8
movl $0x1256, %edx           # imm = 0x1256
leaq 0x640e0(%rip), %rcx     # 0x77393
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x132c1
jmp 0x132e0
leaq 0x63294(%rip), %rdi     # 0x7655c
leaq 0x62629(%rip), %rsi     # 0x758f8
movl $0x1257, %edx           # imm = 0x1257
leaq 0x640b8(%rip), %rcx     # 0x77393
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb20, (%rax)          # imm = 0xB20
jne 0x132ee
jmp 0x1330d
leaq 0x640e1(%rip), %rdi     # 0x773d6
leaq 0x625fc(%rip), %rsi     # 0x758f8
movl $0x1258, %edx           # imm = 0x1258
leaq 0x6408b(%rip), %rcx     # 0x77393
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x44(%rax)
je 0x13321
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x13323
jmp 0x13342
leaq 0x640ce(%rip), %rdi     # 0x773f8
leaq 0x625c7(%rip), %rsi     # 0x758f8
movl $0x125a, %edx           # imm = 0x125A
leaq 0x64056(%rip), %rcx     # 0x77393
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x1336f
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
xorl %esi, %esi
movl $0x3, %edx
callq 0x22a20
leaq -0x28(%rbp), %rdi
callq 0x8c90
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq 0x62e9c(%rip), %rdx     # 0x76223
leaq 0x62e9a(%rip), %rcx     # 0x76228
callq 0x118c0
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x133bb
leaq 0x62b8a(%rip), %rax     # 0x75f3f
movq %rax, -0x40(%rbp)
jmp 0x133c3
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
callq 0x225c0
leaq -0x28(%rbp), %rdi
callq 0x9310
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_stat_vcall
static void _asm_stat_vcall(
	ASMGeneratorGas32Context *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_VCALL);
	assert(node->nchilds == 1);

	ParserASTNode *node_func_call = node->childs[0];
	assert(node_func_call->type == BE_NODE_STAT_FUNC_CALL);
	_asm_stat_func_call(ctx, node_func_call);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x16369
jmp 0x16388
leaq 0x69df1(%rip), %rdi     # 0x80161
leaq 0x5f581(%rip), %rsi     # 0x758f8
movl $0x17fe, %edx           # imm = 0x17FE
leaq 0x62433(%rip), %rcx     # 0x787b6
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x16391
jmp 0x163b0
leaq 0x601c4(%rip), %rdi     # 0x7655c
leaq 0x5f559(%rip), %rsi     # 0x758f8
movl $0x17ff, %edx           # imm = 0x17FF
leaq 0x6240b(%rip), %rcx     # 0x787b6
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xbd1, (%rax)          # imm = 0xBD1
jne 0x163be
jmp 0x163dd
leaq 0x62433(%rip), %rdi     # 0x787f8
leaq 0x5f52c(%rip), %rsi     # 0x758f8
movl $0x1800, %edx           # imm = 0x1800
leaq 0x623de(%rip), %rcx     # 0x787b6
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x163e9
jmp 0x16408
leaq 0x6101e(%rip), %rdi     # 0x7740e
leaq 0x5f501(%rip), %rsi     # 0x758f8
movl $0x1801, %edx           # imm = 0x1801
leaq 0x623b3(%rip), %rcx     # 0x787b6
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xbd2, (%rax)          # imm = 0xBD2
jne 0x16425
jmp 0x16444
leaq 0x623ed(%rip), %rdi     # 0x78819
leaq 0x5f4c5(%rip), %rsi     # 0x758f8
movl $0x1804, %edx           # imm = 0x1804
leaq 0x62377(%rip), %rcx     # 0x787b6
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x25010
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: get_var_symbol_by_id_node
static ParserSymbol * _get_var_symbol_by_id_node(
	ASMGeneratorGas32Context *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_IDENTIFIER);

	ParserSymbol *symbol = parser_get_symbol_from_node(
		ctx->psrctx, node, BE_SYM_VAR, node->token
	);
	if (symbol == NULL) {
		assert(0);
	}

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1f739
jmp 0x1f758
leaq 0x60a21(%rip), %rdi     # 0x80161
leaq 0x561b1(%rip), %rsi     # 0x758f8
movl $0xe7a, %edx            # imm = 0xE7A
leaq 0x56c9c(%rip), %rcx     # 0x763ef
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x1f761
jmp 0x1f780
leaq 0x56df4(%rip), %rdi     # 0x7655c
leaq 0x56189(%rip), %rsi     # 0x758f8
movl $0xe7b, %edx            # imm = 0xE7B
leaq 0x56c74(%rip), %rcx     # 0x763ef
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x1f78e
jmp 0x1f7ad
leaq 0x56cb0(%rip), %rdi     # 0x76445
leaq 0x5615c(%rip), %rsi     # 0x758f8
movl $0xe7c, %edx            # imm = 0xE7C
leaq 0x56c47(%rip), %rcx     # 0x763ef
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movl $0x1, %edx
callq 0x82f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1f7f4
leaq 0x53c7e(%rip), %rdi     # 0x7345a
leaq 0x56115(%rip), %rsi     # 0x758f8
movl $0xe82, %edx            # imm = 0xE82
leaq 0x56c00(%rip), %rcx     # 0x763ef
callq 0x30a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: get_symbol_by_id_node
static ParserSymbol * _get_symbol_by_id_node(
	ASMGeneratorGas32Context *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_IDENTIFIER);

	ParserSymbol *symbol = parser_get_symbol_from_node(
		ctx->psrctx, node, 0, node->token
	);
	if (symbol == NULL) {
		assert(0);
	}

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1f819
jmp 0x1f838
leaq 0x60941(%rip), %rdi     # 0x80161
leaq 0x560d1(%rip), %rsi     # 0x758f8
movl $0xe8c, %edx            # imm = 0xE8C
leaq 0x56c33(%rip), %rcx     # 0x76466
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x1f841
jmp 0x1f860
leaq 0x56d14(%rip), %rdi     # 0x7655c
leaq 0x560a9(%rip), %rsi     # 0x758f8
movl $0xe8d, %edx            # imm = 0xE8D
leaq 0x56c0b(%rip), %rcx     # 0x76466
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x1f86e
jmp 0x1f88d
leaq 0x56bd0(%rip), %rdi     # 0x76445
leaq 0x5607c(%rip), %rsi     # 0x758f8
movl $0xe8e, %edx            # imm = 0xE8E
leaq 0x56bde(%rip), %rcx     # 0x76466
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
xorl %edx, %edx
callq 0x82f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1f8d1
leaq 0x53ba1(%rip), %rdi     # 0x7345a
leaq 0x56038(%rip), %rsi     # 0x758f8
movl $0xe94, %edx            # imm = 0xE94
leaq 0x56b9a(%rip), %rcx     # 0x76466
callq 0x30a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_mov_sym_sym
static void _asm_inst_mov_sym_sym(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	ParserSymbol *target,
	ParserSymbol *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);
	assert(BE_VAR_SYMBOL_GET_TYPE_SIZE(target) == BE_VAR_SYMBOL_GET_TYPE_SIZE(source));

	const char *reg = "";
	switch (BE_VAR_SYMBOL_GET_TYPE_SIZE(target)) {
		case 1: {
			reg = _ASM_REG_NAME_AL;
			break;
		}
		case 2: {
			reg = _ASM_REG_NAME_AX;
			break;
		}
		case 4:
		case 8: {
			reg = _ASM_REG_NAME_EAX;
			break;
		}
		default: {
			assert(0);
			break;
		}
	}

	_asm_inst_mov_x_sym(ctx, rstr, reg, source);
	_asm_inst_mov_sym_x(ctx, rstr, target, reg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1fb91
jmp 0x1fbb0
leaq 0x605c9(%rip), %rdi     # 0x80161
leaq 0x55d59(%rip), %rsi     # 0x758f8
movl $0x310, %edx            # imm = 0x310
leaq 0x56af4(%rip), %rcx     # 0x7669f
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x1fbb9
jmp 0x1fbd8
leaq 0x53f4d(%rip), %rdi     # 0x73b0d
leaq 0x55d31(%rip), %rsi     # 0x758f8
movl $0x311, %edx            # imm = 0x311
leaq 0x56acc(%rip), %rcx     # 0x7669f
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x1fbe1
jmp 0x1fc00
leaq 0x5f74c(%rip), %rdi     # 0x7f334
leaq 0x55d09(%rip), %rsi     # 0x758f8
movl $0x312, %edx            # imm = 0x312
leaq 0x56aa4(%rip), %rcx     # 0x7669f
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x1fc09
jmp 0x1fc28
leaq 0x5c624(%rip), %rdi     # 0x7c234
leaq 0x55ce1(%rip), %rsi     # 0x758f8
movl $0x313, %edx            # imm = 0x313
leaq 0x56a7c(%rip), %rcx     # 0x7669f
callq 0x30a0
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jne 0x1fc3c
jmp 0x1fc5b
leaq 0x56ac6(%rip), %rdi     # 0x76709
leaq 0x55cae(%rip), %rsi     # 0x758f8
movl $0x314, %edx            # imm = 0x314
leaq 0x56a49(%rip), %rcx     # 0x7669f
callq 0x30a0
leaq 0x562dd(%rip), %rax     # 0x75f3f
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
decq %rax
movq %rax, -0x30(%rbp)
subq $0x7, %rax
ja 0x1fcb6
movq -0x30(%rbp), %rax
leaq 0x55c12(%rip), %rcx     # 0x75898
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x56abe(%rip), %rax     # 0x76754
movq %rax, -0x28(%rbp)
jmp 0x1fcd5
leaq 0x56ab5(%rip), %rax     # 0x76758
movq %rax, -0x28(%rbp)
jmp 0x1fcd5
leaq 0x56735(%rip), %rax     # 0x763e5
movq %rax, -0x28(%rbp)
jmp 0x1fcd5
leaq 0x5379d(%rip), %rdi     # 0x7345a
leaq 0x55c34(%rip), %rsi     # 0x758f8
movl $0x326, %edx            # imm = 0x326
leaq 0x569cf(%rip), %rcx     # 0x7669f
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x21250
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x20080
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: asm_inst_mov_sym_x
static void _asm_inst_mov_sym_x(
	ASMGeneratorGas32Context *ctx,
	ResizableString *rstr,
	ParserSymbol *target,
	const char *source
) {
	assert(ctx);
	assert(rstr);
	assert(target);
	assert(source);

	_asm_inst_mov_x_x(
		ctx,
		rstr,
		BE_VAR_SYMBOL_GET_TYPE(target),
		RSTR_CSTR(BE_VAR_SYMBOL_GET_CODE_GEN_NAME(target)),
		source
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x200a1
jmp 0x200c0
leaq 0x600b9(%rip), %rdi     # 0x80161
leaq 0x55849(%rip), %rsi     # 0x758f8
movl $0x2dd, %edx            # imm = 0x2DD
leaq 0x56837(%rip), %rcx     # 0x768f2
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x200c9
jmp 0x200e8
leaq 0x53a3d(%rip), %rdi     # 0x73b0d
leaq 0x55821(%rip), %rsi     # 0x758f8
movl $0x2de, %edx            # imm = 0x2DE
leaq 0x5680f(%rip), %rcx     # 0x768f2
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x200f1
jmp 0x20110
leaq 0x5f23c(%rip), %rdi     # 0x7f334
leaq 0x557f9(%rip), %rsi     # 0x758f8
movl $0x2df, %edx            # imm = 0x2DF
leaq 0x567e7(%rip), %rcx     # 0x768f2
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x20119
jmp 0x20138
leaq 0x5c114(%rip), %rdi     # 0x7c234
leaq 0x557d1(%rip), %rsi     # 0x758f8
movl $0x2e0, %edx            # imm = 0x2E0
leaq 0x567bf(%rip), %rcx     # 0x768f2
callq 0x30a0
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movb 0x30(%rax), %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x2016a
leaq 0x55ddb(%rip), %rax     # 0x75f3f
movq %rax, -0x40(%rbp)
jmp 0x20176
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x40(%rbp)
movb -0x21(%rbp), %al
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %r8
movzbl %al, %edx
callq 0x20f30
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/asmgen_gas32.c
// Function: _asm_inst_reg
static const char * __asm_inst_reg(
	ASMGeneratorGas32Context *ctx,
	uint8_t type,
	int reg,
	const char *_file,
	int _line
) {
	assert(ctx);

	const char *regs[][3] = {
		{_ASM_REG_NAME_AL, _ASM_REG_NAME_AX, _ASM_REG_NAME_EAX},
		{_ASM_REG_NAME_BL, _ASM_REG_NAME_BX, _ASM_REG_NAME_EBX},
		{_ASM_REG_NAME_CL, _ASM_REG_NAME_CX, _ASM_REG_NAME_ECX},
		{_ASM_REG_NAME_DL, _ASM_REG_NAME_DX, _ASM_REG_NAME_EDX}
	};
	assert(reg < sizeof(regs) / sizeof(regs[0]));

	int idx = 0;
	switch (type) {
		case BE_TYPE_CHAR:
		case BE_TYPE_INT8:
		case BE_TYPE_UINT8: {
			idx = 0;
			break;
		}
		case BE_TYPE_INT16:
		case BE_TYPE_UINT16: {
			idx = 1;
			break;
		}
		case BE_TYPE_INT32:
		case BE_TYPE_UINT32:
		case BE_TYPE_FLOAT:
		case BE_TYPE_POINTER: {
			idx = 2;
			break;
		}
		default: {
			fprintf(stderr, "\nERROR: file = %s, line = %d\n\n", _file, _line);
			assert(0);
			break;
		}
	}

	return regs[reg][idx];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x20d39
jmp 0x20d58
leaq 0x5f421(%rip), %rdi     # 0x80161
leaq 0x54bb1(%rip), %rsi     # 0x758f8
movl $0x15f, %edx            # imm = 0x15F
leaq 0x55d94(%rip), %rcx     # 0x76ae7
callq 0x30a0
leaq -0x80(%rbp), %rdi
leaq 0x72f9d(%rip), %rsi     # 0x93d00
movl $0x60, %edx
callq 0x3110
movslq -0x10(%rbp), %rax
cmpq $0x4, %rax
jae 0x20d79
jmp 0x20d98
leaq 0x55de1(%rip), %rdi     # 0x76b61
leaq 0x54b71(%rip), %rsi     # 0x758f8
movl $0x167, %edx            # imm = 0x167
leaq 0x55d54(%rip), %rcx     # 0x76ae7
callq 0x30a0
movl $0x0, -0x84(%rbp)
movzbl -0x9(%rbp), %eax
movl %eax, -0x88(%rbp)
decl %eax
subl $0x2, %eax
jb 0x20e10
jmp 0x20db5
movl -0x88(%rbp), %eax
subl $0x3, %eax
je 0x20e1c
jmp 0x20dc2
movl -0x88(%rbp), %eax
subl $0x4, %eax
je 0x20e28
jmp 0x20dcf
movl -0x88(%rbp), %eax
subl $0x6, %eax
je 0x20e10
jmp 0x20ddc
movl -0x88(%rbp), %eax
subl $0x7, %eax
je 0x20e1c
jmp 0x20de9
movl -0x88(%rbp), %eax
subl $0x8, %eax
je 0x20e28
jmp 0x20df6
movl -0x88(%rbp), %eax
subl $0xa, %eax
je 0x20e28
jmp 0x20e03
movl -0x88(%rbp), %eax
subl $0x10, %eax
je 0x20e28
jmp 0x20e34
movl $0x0, -0x84(%rbp)
jmp 0x20e72
movl $0x1, -0x84(%rbp)
jmp 0x20e72
movl $0x2, -0x84(%rbp)
jmp 0x20e72
movq 0x731bd(%rip), %rax     # 0x93ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq 0x55d3a(%rip), %rsi     # 0x76b86
movb $0x0, %al
callq 0x30f0
leaq 0x52600(%rip), %rdi     # 0x7345a
leaq 0x54a97(%rip), %rsi     # 0x758f8
movl $0x17f, %edx            # imm = 0x17F
leaq 0x55c7a(%rip), %rcx     # 0x76ae7
callq 0x30a0
movslq -0x10(%rbp), %rcx
leaq -0x80(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x84(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)