LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: parseSecondEighthNoteEventDurations
static DoubleArray *
parseSecondEighthNoteEventDurations(char *eighthNoteTimingEvents)
    {
//printf("[parseSecondEighthNoteEventDurations]\n");
    StringArray *timingEventsBySixteenthNote;
    DoubleArray *retVal = 0;
    
//printf("\t\t[%s]\n", eighthNoteTimingEvents);
    
    /* attempt to split into sixteenth notes */
    timingEventsBySixteenthNote = splitTimingEvents(eighthNoteTimingEvents, "&a");

    /* unable to split; return */
    if (timingEventsBySixteenthNote == 0 || timingEventsBySixteenthNote->length != 2) 
        {
//printf("[parseSecondEighthNoteEventDurations] unable to split '%s' into sixteenth notes\n", eighthNoteTimingEvents);
        return parseGenericTimingEvents(eighthNoteTimingEvents, 1.0/8);
        }
        
//printf("[parseSecondEighthNoteEventDurations] first concat: %s\n", timingEventsBySixteenthNote->values[0]);
    retVal = concatDoubleArrays(retVal, parseGenericTimingEvents(timingEventsBySixteenthNote->values[0], 1.0/16));
//printf("[parseSecondEighthNoteEventDurations] second concat: %s\n", timingEventsBySixteenthNote->values[1]);
    retVal = concatDoubleArrays(retVal, parseGenericTimingEvents(timingEventsBySixteenthNote->values[1], 1.0/16));
//printf("[parseSecondEighthNoteEventDurations] after concat\n");
    
    return retVal;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2162(%rip), %rsi      # 0x8491
callq 0x5a20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6349
movq -0x18(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0x6360
movq -0x10(%rbp), %rdi
movsd 0xd43(%rip), %xmm0      # 0x7098
callq 0x6170
movq %rax, -0x8(%rbp)
jmp 0x63c7
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movsd 0xd16(%rip), %xmm0      # 0x7090
callq 0x6170
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x5c10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
movsd 0xce6(%rip), %xmm0      # 0x7090
callq 0x6170
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x5c10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/test/../src/trie.h
// Function: JFT_key
static inline JFT_Stem JFT_key(const JFT *trie, uint8_t *keyData) {
  JFT_Stem key = (JFT_Stem) {.data = keyData + JFT_KEY_LIMIT};
  for (JFT *node = (JFT *)trie; JFT_node_type(node) != Root; node = JFT_parent(node)) {
    JFT_Stem stem = JFT_stem(node);
    JFT_KeySize n = stem.size - !!stem.pre;
    key.pre = stem.pre;
    key.size += stem.size;
    key.data = memcpy(key.data - n, stem.data, n);
  }
  return key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq $0x0, (%rdi)
movw $0x0, 0x8(%rdi)
movq -0x10(%rbp), %rax
addq $0x400, %rax            # imm = 0x400
movq %rax, 0x10(%rdi)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1cb0
cmpl $0x0, %eax
je 0x1ad8
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1b10
movq -0x48(%rbp), %rax
movzwl -0x28(%rbp), %ecx
cmpq $0x0, -0x30(%rbp)
setne %dl
xorb $-0x1, %dl
xorb $-0x1, %dl
andb $0x1, %dl
movzbl %dl, %edx
subl %edx, %ecx
movw %cx, -0x32(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movzwl -0x28(%rbp), %edx
movzwl 0x8(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x8(%rax)
movq 0x10(%rax), %rdi
movzwl -0x32(%rbp), %eax
movslq %eax, %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq %rdi, -0x50(%rbp)
movq -0x20(%rbp), %rsi
movzwl -0x32(%rbp), %eax
movl %eax, %edx
callq 0x1130
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x21a0
movq %rax, -0x18(%rbp)
jmp 0x1a3e
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/test/../src/trie.h
// Function: JFT_node_type_name
static inline const char *JFT_node_type_name(const JFT *trie) {
  switch (JFT_node_type(trie)) {
    case Root:      return "Root";
    case ScanList:  return "ScanList";
    case JumpTable: return "JumpTable";
    case Leaf:      return "Leaf";
    default:        return "N/A";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1cb0
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x1c18
movq -0x18(%rbp), %rax
leaq 0x7445(%rip), %rcx      # 0x9020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x761d(%rip), %rax      # 0x9208
movq %rax, -0x8(%rbp)
jmp 0x1c23
leaq 0x7615(%rip), %rax      # 0x920d
movq %rax, -0x8(%rbp)
jmp 0x1c23
leaq 0x7611(%rip), %rax      # 0x9216
movq %rax, -0x8(%rbp)
jmp 0x1c23
leaq 0x760e(%rip), %rax      # 0x9220
movq %rax, -0x8(%rbp)
jmp 0x1c23
leaq 0x7606(%rip), %rax      # 0x9225
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/test/../src/trie.h
// Function: JFT_symbol_name
static inline const char *JFT_symbol_name(const JFT_Symbol *symbol) {
  switch (*symbol) {
    case JFT_SYMBOL_ANY:     return "ANY";
    case JFT_SYMBOL_NIL:     return "NIL";
    case JFT_SYMBOL_TOP:     return "TOP";
    case JFT_SYMBOL_PRIMARY: return "PRIMARY";
    case JFT_SYMBOL_INDICES: return "INDICES";
    default:                 return (const char *)symbol;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x5, %rax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x2192
movq -0x18(%rbp), %rax
leaq 0x6ee8(%rip), %rcx      # 0x9030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x71fb(%rip), %rax      # 0x9353
movq %rax, -0x8(%rbp)
jmp 0x219a
leaq 0x71f2(%rip), %rax      # 0x9357
movq %rax, -0x8(%rbp)
jmp 0x219a
leaq 0x71e9(%rip), %rax      # 0x935b
movq %rax, -0x8(%rbp)
jmp 0x219a
leaq 0x71e0(%rip), %rax      # 0x935f
movq %rax, -0x8(%rbp)
jmp 0x219a
leaq 0x71db(%rip), %rax      # 0x9367
movq %rax, -0x8(%rbp)
jmp 0x219a
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/rose.c
// Function: main
int main(int argc, char *argv[])
{
	Module *m;
	Thread t;
	const char *file = argc > 1 ? argv[1] : "out.rmd";
	loader_add_dir_from_file(file);
	loader_add_dirs_from_env();
	heap_create();

   	m = module_load_obligatory(file);
	if(thread_init(&t, m, "main") < 0)
		return 1;
	thread_run(&t);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2450, %rsp           # imm = 0x2450
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x12b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x2450(%rbp)
jmp 0x12c0
leaq 0x4d4d(%rip), %rax      # 0x6004
movq %rax, -0x2450(%rbp)
jmp 0x12c0
movq -0x2450(%rbp), %rax
movq %rax, -0x2448(%rbp)
movq -0x2448(%rbp), %rdi
callq 0x5370
callq 0x52d0
callq 0x4200
movq -0x2448(%rbp), %rdi
callq 0x14f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x2440(%rbp), %rdi
leaq 0x4d06(%rip), %rdx      # 0x600c
callq 0x2120
cmpl $0x0, %eax
jge 0x1319
movl $0x1, -0x4(%rbp)
jmp 0x132c
leaq -0x2440(%rbp), %rdi
callq 0x2490
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2450, %rsp           # imm = 0x2450
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/module.c
// Function: module_load
Module *module_load(const char *path, const char **errstr)
{
	FILE *f = fopen(path, "rb");
	if(f)
		return load_header(f, errstr);

	*errstr = sys_error();
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4cb6(%rip), %rsi      # 0x6011
callq 0x1140
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x137e
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13b0
movq %rax, -0x8(%rbp)
jmp 0x139c
callq 0x1060
movl (%rax), %edi
callq 0x1170
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/module.c
// Function: load_header
static Module *load_header(FILE *f, const char **errstr)
{
	RMDHeader h;
	Module *m = NULL;

	if (read_header(f, &h) < 0) {
		*errstr = sys_error();
		goto error;
	}

	if(!verify_ident(h.ident)) {
		*errstr = "no RMD signature";
		goto error;
	}

	if(!verify_rose_version(h.rmd_version)) {
		*errstr = "unsupported ROSE version";
		goto error;
	}

	m = module_new(&h);
	if (!m) {
		*errstr = "no memory";
		goto error;
	}

	if (read_module(f, m) < 0) {
		*errstr = sys_error();
		goto error;
	}

	m->name = get_symbol(m, h.name);
	add_to_tbl(m, m->name);

	return m;

error:
	if (m)
		free(m);
	if(f)
		fclose(f);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x1820
cmpl $0x0, %eax
jge 0x13f5
callq 0x1060
movl (%rax), %edi
callq 0x1170
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x14b3
leaq -0x44(%rbp), %rdi
callq 0x1a20
cmpl $0x0, %eax
jne 0x1416
movq -0x18(%rbp), %rax
leaq 0x4c3e(%rip), %rcx      # 0x604c
movq %rcx, (%rax)
jmp 0x14b3
movzwl -0x40(%rbp), %edi
callq 0x1a50
cmpl $0x0, %eax
jne 0x1434
movq -0x18(%rbp), %rax
leaq 0x4c2e(%rip), %rcx      # 0x605d
movq %rcx, (%rax)
jmp 0x14b3
leaq -0x44(%rbp), %rdi
callq 0x1a70
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x1458
movq -0x18(%rbp), %rax
leaq 0x4c23(%rip), %rcx      # 0x6076
movq %rcx, (%rax)
jmp 0x14b3
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x1cc0
cmpl $0x0, %eax
jge 0x1482
callq 0x1060
movl (%rax), %edi
callq 0x1170
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x14b3
movq -0x50(%rbp), %rdi
movzwl -0x3e(%rbp), %esi
callq 0x1f90
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rdi
movq -0x50(%rbp), %rax
movq (%rax), %rsi
callq 0x1fb0
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14db
cmpq $0x0, -0x50(%rbp)
je 0x14c3
movq -0x50(%rbp), %rdi
callq 0x1040
cmpq $0x0, -0x10(%rbp)
je 0x14d3
movq -0x10(%rbp), %rdi
callq 0x1090
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/module.c
// Function: module_load_obligatory
Module *module_load_obligatory(const char *path)
{
	const char *errstr;
	Module *m = module_load(path, &errstr);
	if(!m) {
		printf("%s: %s\n", path, errstr);
		exit(1);
	}
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1340
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1534
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x4af1(%rip), %rdi      # 0x6014
movb $0x0, %al
callq 0x10c0
movl $0x1, %edi
callq 0x1150
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/module.c
// Function: module_get
Module *module_get(Symbol *name, const char **errstr)
{
	SymbolValue *v;
	FILE *f;

   	v = symtbl_find(&module_tbl, name);
	if(v)
		return v->p;

	f = loader_find_module(name);
	if(f)
		return load_header(f, errstr);

	*errstr = "can not find module";
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x7bbd(%rip), %rdi      # 0x9118
callq 0x4cb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1578
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x15b5
movq -0x10(%rbp), %rdi
callq 0x53e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x159f
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13b0
movq %rax, -0x8(%rbp)
jmp 0x15b5
movq -0x18(%rbp), %rax
leaq 0x4a72(%rip), %rcx      # 0x601c
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/module.c
// Function: module_get_obligatory
Module *module_get_obligatory(Symbol *name)
{
	const char *errstr;
	Module *m = module_get(name, &errstr);
	if(!m) {
		fprintf(stderr, "%s: %s\n", name, errstr);
		exit(1);
	}
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1540
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x160e
movq 0x7a05(%rip), %rax      # 0x8ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x4a17(%rip), %rsi      # 0x6014
movb $0x0, %al
callq 0x1110
movl $0x1, %edi
callq 0x1150
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/module.c
// Function: module_get_module
Module *module_get_module(Module *m, RA_Module idx)
{
	const Segments *const seg = &m->seg;
	const RMDModule *mod = mtbl_get(seg, idx);
	Symbol *modname = sym_get(seg, mod->name);
	Module *other = module_get_obligatory(modname);
	return other;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movzbl -0x9(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x20(%rbp), %rcx
movzwl (%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x15c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/module.c
// Function: module_exp_get_obligatory
RA_Export module_exp_get_obligatory(const Module *m,
		Symbol *name, RA_Export hint)
{
	if(!module_exp_find(m, name, &hint)) {
		fprintf(stderr, "%s.%s: procedure not found\n",
				module_name(m), name);
		exit(1);
	}
	return hint;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x11(%rbp), %rdx
callq 0x1700
cmpl $0x0, %eax
jne 0x16e8
movq 0x792e(%rip), %rax      # 0x8ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rcx
leaq 0x4959(%rip), %rsi      # 0x6030
movb $0x0, %al
callq 0x1110
movl $0x1, %edi
callq 0x1150
movb -0x11(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/module.c
// Function: module_exp_find
static int module_exp_find(const Module *m, Symbol *name, RA_Export *proc)
{
	int i;
	const Segments *seg = &m->seg;
	const Exp *exp = &seg->exp;
	Symbol *tryname;
	if (*proc < exp->size) {
		tryname = sym_get(seg, *proc);
		if(strcmp(name, tryname) == 0)
			return 1;
	}
	for(i = 0; i != exp->size; ++i) {
		const RMDExport *e = &exp->start[i];
		tryname = sym_get(seg, e->name);
		if(strcmp(name, tryname) == 0) {
			*proc = i;
			return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movq -0x38(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x176e
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1100
cmpl $0x0, %eax
jne 0x176c
movl $0x1, -0x4(%rbp)
jmp 0x17ea
jmp 0x176e
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x38(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
je 0x17e3
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x48(%rbp), %rcx
movzwl (%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1100
cmpl $0x0, %eax
jne 0x17d6
movl -0x24(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x17ea
jmp 0x17d8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1775
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/module.c
// Function: read_header
static int read_header(FILE *f, RMDHeader *h)
{
	if (!rd(f, &h->ident, 4)
			|| !srd(f, &h->rmd_version.maj, 1)
			|| !srd(f, &h->rmd_version.min, 1)
			|| !srd(f, &h->name, 2)
			|| !srd(f, &h->version.maj, 1)
			|| !srd(f, &h->version.min, 1)
			|| !srd(f, &h->sizes.exp, 1)
			|| !srd(f, &h->sizes.ptbl, 1)
			|| !srd(f, &h->sizes.mtbl, 1)
			|| !srd(f, &h->sizes.imp, 1)
			|| !srd(f, &h->sizes.text, 4)
			|| !srd(f, &h->sizes.sym, 2)
			|| !srd(f, &h->sizes.str, 4)
			|| !srd(f, &h->datac, 1)
			|| !srd(f, &h->flags, 1)
			|| !srd(f, &h->size, 4)
			|| !rd(f, &h->pad, 8))
		goto err;
	return 0;
err:
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1080
cmpq $0x0, %rax
jbe 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
callq 0x1ff0
cmpl $0x0, %eax
je 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x4, %rsi
addq $0x1, %rsi
callq 0x1ff0
cmpl $0x0, %eax
je 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x6, %rsi
callq 0x2030
cmpl $0x0, %eax
je 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x1ff0
cmpl $0x0, %eax
je 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
addq $0x1, %rsi
callq 0x1ff0
cmpl $0x0, %eax
je 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
callq 0x1ff0
cmpl $0x0, %eax
je 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
addq $0x1, %rsi
callq 0x1ff0
cmpl $0x0, %eax
je 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
addq $0x2, %rsi
callq 0x1ff0
cmpl $0x0, %eax
je 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
addq $0x3, %rsi
callq 0x1ff0
cmpl $0x0, %eax
je 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
addq $0x4, %rsi
callq 0x20a0
cmpl $0x0, %eax
je 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
addq $0x8, %rsi
callq 0x2030
cmpl $0x0, %eax
je 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
addq $0xc, %rsi
callq 0x20a0
cmpl $0x0, %eax
je 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1c, %rsi
callq 0x1ff0
cmpl $0x0, %eax
je 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1d, %rsi
callq 0x1ff0
cmpl $0x0, %eax
je 0x1a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
callq 0x20a0
cmpl $0x0, %eax
je 0x1a04
movq -0x18(%rbp), %rdi
addq $0x24, %rdi
movq -0x10(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x1080
cmpq $0x0, %rax
ja 0x1a06
jmp 0x1a0f
movl $0x0, -0x4(%rbp)
jmp 0x1a16
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/module.c
// Function: srd2
static int srd2(FILE *f, void *buf)
{
	char b[2];
	int ret;
	if (fread(b, 2, 1, f) == 0)
		return 0;
	ret = b[0] | (b[1] >> 8);
	memcpy(buf, &ret, 2);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x1a(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x2, %esi
movl $0x1, %edx
callq 0x1080
cmpq $0x0, %rax
jne 0x2066
movl $0x0, -0x4(%rbp)
jmp 0x2088
movsbl -0x1a(%rbp), %eax
movsbl -0x19(%rbp), %ecx
sarl $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movw -0x20(%rbp), %cx
movw %cx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/module.c
// Function: srd4
static int srd4(FILE *f, void *buf)
{
	char b[4];
	long ret;
	if (fread(b, 4, 1, f) == 0)
		return 0;
	ret = b[0] | (b[1] >> 8) | (b[2] >> 16) | (b[3] >> 24);
	memcpy(buf, &ret, 4);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x1c(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1080
cmpq $0x0, %rax
jne 0x20d6
movl $0x0, -0x4(%rbp)
jmp 0x210b
movsbl -0x1c(%rbp), %eax
movsbl -0x1b(%rbp), %ecx
sarl $0x8, %ecx
orl %ecx, %eax
movsbl -0x1a(%rbp), %ecx
sarl $0x10, %ecx
orl %ecx, %eax
movsbl -0x19(%rbp), %ecx
sarl $0x18, %ecx
orl %ecx, %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/thread.c
// Function: thread_init
int thread_init(Thread *t, struct Module *m, Symbol *proc)
{
	const Segments *seg = &m->seg;
	RA_Export exp_idx = module_exp_get_obligatory(m, proc, 0);

	const RMDExport *exp = exp_get(seg, exp_idx);
	const RMDProcedure *ptbl_ent = ptbl_get(seg, exp->idx);
	t->pc.byte = text_get(seg, ptbl_ent->addr);

	t->vars = t->vstack;
	t->vars_end = t->vars + sizeof t->vstack / sizeof t->vstack[0] - 1;

	/* Create first stack frame manually as if startup code
	   calls function @proc. There is only 'exit' instruction
	   in startup code, so we do not need all fields */
	t->pstack[0].retaddr = startup_code;
	t->pstack[0].proc = ptbl_ent;
	t->pstack[0].module = m;
	t->procs = t->pstack;
	t->procs_end = t->procs + sizeof t->pstack / sizeof t->pstack[0] - 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x1690
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movzbl -0x21(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x38(%rbp), %rax
movl (%rax), %eax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2420(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2000(%rax)
movq -0x8(%rbp), %rax
movq 0x2000(%rax), %rcx
addq $0x2000, %rcx           # imm = 0x2000
addq $-0x4, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2008(%rax)
movq -0x8(%rbp), %rax
leaq 0x417a(%rip), %rcx      # 0x6354
movq %rcx, 0x2020(%rax)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2018(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2010(%rax)
movq -0x8(%rbp), %rcx
addq $0x2010, %rcx           # imm = 0x2010
movq -0x8(%rbp), %rax
movq %rcx, 0x2410(%rax)
movq -0x8(%rbp), %rax
movq 0x2410(%rax), %rcx
addq $0x400, %rcx            # imm = 0x400
addq $-0x20, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x2418(%rax)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/thread.c
// Function: thread_call_intern
int thread_call_intern(Thread *t, Module *module, RA_Proc p_idx)
{
	const Segments *seg = &module->seg;
	const RMDProcedure *p = ptbl_get(seg, p_idx);
	if(alloc_frame(t, p) || save_procedure(t, p))
		return -1;
	t->pc.byte = text_get(seg, p->addr);
	t->procs->module = module;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movzbl -0x19(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x22f0
cmpl $0x0, %eax
jne 0x229c
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2380
cmpl $0x0, %eax
je 0x22a5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x22da
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x30(%rbp), %rax
movl (%rax), %eax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x2420(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x2410(%rax), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/thread.c
// Function: alloc_frame
static int alloc_frame(Thread *t, const RMDProcedure *np)
{
	const RMDProcedure *cp = t->procs->proc; /* current procedure descriptor */
	int cur_len = cp->argc + cp->varc; /* current stack length */
	/* allocate new stack frame; arguments are in current frame */
	t->vars += cur_len - np->argc;
	if(t->vars > t->vars_end)
		return -1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x2410(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0xa(%rax), %eax
movq -0x20(%rbp), %rcx
movzbl 0xb(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edx
movq -0x18(%rbp), %rax
movzbl 0xa(%rax), %eax
subl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x2000(%rax), %rcx
movslq %edx, %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x2000(%rax)
movq -0x10(%rbp), %rax
movq 0x2000(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x2008(%rcx), %rax
jbe 0x236e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2375
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/thread.c
// Function: save_procedure
static int save_procedure(Thread *t, const RMDProcedure *proc)
{
	ActivRecord *r = ++t->procs;
	if(r > t->procs_end)
		return -1;
	r->proc    = proc;
	r->varbase = t->vars;
	r->retaddr = t->pc.byte;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq 0x2410(%rcx), %rax
addq $0x20, %rax
movq %rax, 0x2410(%rcx)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x2418(%rcx), %rax
jbe 0x23c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x23f9
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x2000(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x2420(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/heap.c
// Function: heap_alloc
RefData *heap_alloc(R_Word size)
{
	RefData *d = (RefData*)hcur;
	d->size = size;
	hcur += size;
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x56c2(%rip), %rax      # 0x9920
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x4(%rbp), %ecx
movq 0x56ab(%rip), %rax      # 0x9920
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x569e(%rip)      # 0x9920
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/array.c
// Function: bytearray_load
RD_ByteArray *bytearray_load(const void *source)
{
	RA_Array size = deserial(*(RA_Array*)source);
	RD_ByteArray *a = bytearray_new(size);
	memcpy(a + 1, (RA_Array*)source + 1, size);
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x43a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
callq 0x1120
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/object.c
// Function: object_new
RD_Object *object_new(struct Module *module)
{
	RD_Object *o = (RD_Object*)heap_alloc(
			sizeof(RD_Object) + module_data_size(module));
	o->module = module;
	return o;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x80(%rax), %eax
addq $0x10, %rax
movl %eax, %edi
callq 0x4250
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/file.c
// Function: file_open
RD_File *file_open(const RD_ByteArray *name, R_Byte mode)
{
	const scheme *s;
	const R_Byte *fname;
	char *c_fname;
	int len;
	RD_File *f;

	s = get_scheme(name);

	/* make a zero-terminated string copy without scheme prefix */
	fname = bytearray_data_c(name);
	len = bytearray_length(name) + 1;
	fname += s->name.len;
	len -= s->name.len;;

	c_fname = malloc(len);
	memcpy(c_fname, fname, len);
	c_fname[len] = '\0';

	f = s->open(c_fname, mode);

	free(c_fname);
	return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4740
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4590
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4430
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rdi
callq 0x1130
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
callq 0x1120
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rdi
movzbl -0x9(%rbp), %esi
callq *%rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1040
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/file.c
// Function: get_scheme
static const scheme *get_scheme(const RD_ByteArray *path)
{
	int i;
	int path_len = bytearray_length(path);
	const R_Byte *path_str = bytearray_data_c(path);

	for (i = 0; i != sizeof(schemes) / sizeof(schemes[0]); ++i) {
		int prefix_len = schemes[i]->name.len;
		if (prefix_len <= path_len && memcmp(path_str,
								schemes[i]->name.data, prefix_len) == 0)
				return schemes[i];
	}

	return &s_default;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4430
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4590
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x2, %rax
je 0x47d9
movslq -0x14(%rbp), %rcx
leaq 0x454f(%rip), %rax      # 0x8cd0
movq (%rax,%rcx,8), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x47cc
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x452e(%rip), %rax      # 0x8cd0
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
movslq -0x24(%rbp), %rdx
callq 0x10f0
cmpl $0x0, %eax
jne 0x47cc
movslq -0x14(%rbp), %rcx
leaq 0x450e(%rip), %rax      # 0x8cd0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x47e4
jmp 0x47ce
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x476c
leaq 0x4500(%rip), %rax      # 0x8ce0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/file.c
// Function: file_local_read
R_Word file_local_read(RD_File *f, struct RD_ByteArray *a, R_Word size)
{
	LocalFile *lf = (LocalFile*)f;
	R_Word sz = bytearray_length(a);

	if (sz < size)
		size = sz;
	return fread(bytearray_data(a), size, 1, lf->file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4430
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4905
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4570
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movl $0x1, %edx
callq 0x1080
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/file.c
// Function: file_local_write
R_Word file_local_write(RD_File *f, const struct RD_ByteArray *a, R_Word size)
{
	LocalFile *lf = (LocalFile*)f;
	R_Word sz = bytearray_length(a);
	if (sz < size)
		size = sz;
	return fwrite(bytearray_data_c(a), size, 1, lf->file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4430
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4965
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4590
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movl $0x1, %edx
callq 0x1160
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/file.c
// Function: local_open
static RD_File *local_open(const char *name, R_Byte mode)
{
	LocalFile *f;
	FILE *file;
	const char *mode_s;

	mode_s = f_mode(mode);
	if (!mode_s)
		return RD_null;

	file = fopen(name, mode_s);
	if(!file)
		return RD_null;

	f = (LocalFile*)heap_alloc(sizeof(LocalFile));
	f->file = file;
	f->obj.op = &op_local;

	return &f->obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %edi
callq 0x4a20
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x49c0
movq $0x0, -0x8(%rbp)
jmp 0x4a13
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1140
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x49e2
movq $0x0, -0x8(%rbp)
jmp 0x4a13
movl $0x18, %edi
callq 0x4250
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
leaq 0x4321(%rip), %rcx      # 0x8d28
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/file.c
// Function: f_mode
static const char *f_mode(R_Byte mode)
{
	switch (mode) {
		case F_R: return "r";
		case F_W: return "w";
		case F_RW: return "r+";
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x4a4c
jmp 0x4a38
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x4a59
jmp 0x4a42
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x4a66
jmp 0x4a73
leaq 0x1986(%rip), %rax      # 0x63d9
movq %rax, -0x8(%rbp)
jmp 0x4a7b
leaq 0x1959(%rip), %rax      # 0x63b9
movq %rax, -0x8(%rbp)
jmp 0x4a7b
leaq 0x194e(%rip), %rax      # 0x63bb
movq %rax, -0x8(%rbp)
jmp 0x4a7b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/file_rose.c
// Function: file_rose_open
RD_File *file_rose_open(const char *name, R_Byte mode)
{
	int len;
	const File *f;

	len = strlen(name);
	for (f = rose_f; f->open; ++f)
		if (f->name.len  == len && memcmp(f->name.data, name, len) == 0)
			return (f->mode & mode) ? f->open(name) : RD_null;

	return RD_null;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movl %eax, -0x18(%rbp)
leaq 0x428b(%rip), %rax      # 0x8d40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4b31
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x4b21
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x10f0
cmpl $0x0, %eax
jne 0x4b21
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movzbl -0x11(%rbp), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x4b0f
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x28(%rbp)
jmp 0x4b17
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x4b17
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4b39
jmp 0x4b23
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0x4ab9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rose/file_rose.c
// Function: stdio_open
static RD_File *stdio_open(const char *name, FILE *file)
{
	LocalFile *f;

	f = (LocalFile*)heap_alloc(sizeof(LocalFile));
	f->file = file;
	f->obj.op = &op_stdio;

	return &f->obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x4250
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
leaq 0x41ab(%rip), %rcx      # 0x8dc0
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/lib/symtbl.c
// Function: symtbl_init
void symtbl_init(SymbolTable *tbl)
{
	int i;
	FOREACH(i, tbl)
		SLIST_INIT(&tbl->heads[i]);
	tbl->size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0x100, %rax            # imm = 0x100
je 0x4c7a
jmp 0x4c5d
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x4c6f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4c4f
movq -0x8(%rbp), %rax
movl $0x0, 0x800(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/lib/symtbl.c
// Function: symtbl_find
SymbolValue *symtbl_find(const SymbolTable *tbl, Symbol *s)
{
	unsigned char idx = symbol_hash(s);
	const SymbolSlistHead *list = &tbl->heads[idx];
	SymbolEntry *e = list_find(list, s);
	if(e)
		return &e->value;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4d20
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movzbl -0x19(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4d60
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4d05
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x4d0d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/lib/symtbl.c
// Function: symbol_hash
static unsigned char symbol_hash(Symbol *s)
{
	unsigned char h = 0;
	const char *c;
	for (c = s; *c; ++c)
		h += *c;
	return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4d5b
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movzbl -0x9(%rbp), %eax
addl %ecx, %eax
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4d34
movb -0x9(%rbp), %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/lib/symtbl.c
// Function: list_find
static SymbolEntry *list_find(const SymbolSlistHead *head, Symbol *s)
{
	SymbolEntry *ent;
	SLIST_FOREACH(ent, head, le)
		if(strcmp(ent->symbol, s) == 0)
			return ent;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4db1
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1100
cmpl $0x0, %eax
jne 0x4da1
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4db9
jmp 0x4da3
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4d7b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/lib/symtbl.c
// Function: symtbl_add_unique
SymbolValue *symtbl_add_unique(SymbolTable *tbl, Symbol *symbol)
{
	unsigned char idx = symbol_hash(symbol);
	SymbolSlistHead *list = &tbl->heads[idx];
	SymbolEntry *ent = list_find(list, symbol);
	if(ent)
		return NULL;
	return add(tbl, list, symbol);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4d20
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movzbl -0x19(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4d60
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4e21
movq $0x0, -0x8(%rbp)
jmp 0x4e36
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4e40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/lib/symtbl.c
// Function: add
static SymbolValue *add(SymbolTable *tbl, SymbolSlistHead *list, Symbol *s)
{
	SymbolEntry *e = mm_alloc(SymbolEntry);
	e->symbol = s;
	SLIST_INSERT_HEAD(list, e, le);
	++tbl->size;
	return &e->value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x4285(%rip), %rdi      # 0x90e0
callq 0x5050
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x800(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x800(%rax)
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/lib/symtbl.c
// Function: symtbl_add_or_get
SymbolValue *symtbl_add_or_get(SymbolTable *tbl, Symbol *symbol)
{
	unsigned char idx = symbol_hash(symbol);
	SymbolSlistHead *list = &tbl->heads[idx];
	SymbolEntry *ent = list_find(list, symbol);
	if(ent)
		return &ent->value;
	return add(tbl, list, symbol);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4d20
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movzbl -0x19(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4d60
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4f05
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x4f1a
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4e40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/lib/symtbl.c
// Function: symtbl_clear
void symtbl_clear(SymbolTable *tbl)
{
	int i;
	FOREACH(i, tbl) {
		SymbolSlistHead *head = &tbl->heads[i];
		while(!SLIST_EMPTY(head)) {
			//TODO delete symbol?
			mm_free(SymbolEntry, SLIST_FIRST(head));
			SLIST_REMOVE_HEAD(head, le);
		}
	}
	tbl->size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0x100, %rax            # imm = 0x100
je 0x4fb5
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4f71
jmp 0x4fa8
jmp 0x4f73
movq 0x4166(%rip), %rcx      # 0x90e0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x414e(%rip)      # 0x90e0
jmp 0x4f94
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4f5e
jmp 0x4faa
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4f3f
movq -0x8(%rbp), %rax
movl $0x0, 0x800(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/lib/symtbl.c
// Function: symtbl_foreach
void symtbl_foreach(const SymbolTable *tbl,
		void (*fn)(Symbol *sym, const SymbolValue *val))
{
	int i;
	FOREACH(i, tbl) {
		const SymbolSlistHead *head = &tbl->heads[i];
		const SymbolEntry *ent;
		SLIST_FOREACH(ent, head, le)
			fn(ent->symbol, &ent->value);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x100, %rax            # imm = 0x100
je 0x5048
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x503b
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rdi
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
callq *%rax
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x5011
jmp 0x503d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4fe7
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/lib/./mm.h
// Function: mm_get_chunk
C_ATTR_MALLOC
static inline void *mm_get_chunk(struct mm_pool_struct *pool)
{
	void *head;
	void mm_pool_alloc(struct mm_pool_struct *pool);


	if(unlikely(!pool->head))
		mm_pool_alloc(pool);
	head = pool->head;
	pool->head = *(void **)head;

	return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x5083
movq -0x8(%rbp), %rdi
callq 0x50b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)