LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DASrealign.c
// Function: good
static inline int good(Finger *cur, int pos)
{ int blen, *map;

  map  = cur->map;
  blen = cur->blen;
  if (blen == 0)
    { while (cur->cidx < cur->lidx && pos >= map[cur->cidx])
        { cur->dist += (map[cur->cidx-2] - cur->last) + map[cur->cidx-1];
          cur->last  = map[cur->cidx];
          cur->cidx += 3; 
        }
      if (pos <= map[cur->cidx-2])
        { if (pos < cur->last)
            return (-1);
          else
            return (cur->dist + (pos-cur->last));
        }
    }
  else
    { while (cur->cidx > cur->lidx && pos >= blen - map[cur->cidx])
        { cur->dist += ((blen - map[cur->cidx+2]) - cur->last) + map[cur->cidx+1];
          cur->last  = blen - map[cur->cidx];
          cur->cidx -= 3; 
        }
      if (pos <= blen - map[cur->cidx+2])
        { if (pos < cur->last)
            return (-1);
          else
            return (cur->dist + (pos-cur->last));
        }
    }
  return (-1);
}

// Assembly:
pushq %rbp
pushq %rbx
movq 0x18(%rdi), %rcx
movl 0x10(%rdi), %r8d
movslq 0x4(%rdi), %rax
movslq (%rdi), %rdx
testl %r8d, %r8d
je 0x2dbf
movq %rdx, %r9
shlq $0x20, %r9
leal -0x3(%rdx), %r10d
movabsq $-0x300000000, %r11     # imm = 0xFFFFFFFD00000000
cmpq %rax, %rdx
jle 0x2daa
movl %r8d, %ebx
subl (%rcx,%rdx,4), %ebx
cmpl %esi, %ebx
jg 0x2daa
movl 0x8(%rcx,%rdx,4), %ebx
addl 0xc(%rdi), %ebx
movl %r8d, %ebp
subl %ebx, %ebp
addl 0x4(%rcx,%rdx,4), %ebp
addl %ebp, 0x8(%rdi)
movl %r8d, %ebx
subl (%rcx,%rdx,4), %ebx
movl %ebx, 0xc(%rdi)
addq $-0x3, %rdx
movl %r10d, (%rdi)
addq %r11, %r9
addl $-0x3, %r10d
jmp 0x2d6f
sarq $0x1e, %r9
subl 0x8(%rcx,%r9), %r8d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %esi, %r8d
jge 0x2e18
jmp 0x2e26
movq %rdx, %r8
shlq $0x20, %r8
leal 0x3(%rdx), %r9d
movabsq $0x300000000, %r10      # imm = 0x300000000
cmpq %rax, %rdx
jge 0x2e08
cmpl %esi, (%rcx,%rdx,4)
jg 0x2e08
movl -0x8(%rcx,%rdx,4), %r11d
subl 0xc(%rdi), %r11d
addl -0x4(%rcx,%rdx,4), %r11d
addl %r11d, 0x8(%rdi)
movl (%rcx,%rdx,4), %r11d
movl %r11d, 0xc(%rdi)
addq $0x3, %rdx
movl %r9d, (%rdi)
addq %r10, %r8
addl $0x3, %r9d
jmp 0x2dd4
sarq $0x1e, %r8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %esi, -0x8(%rcx,%r8)
jl 0x2e26
movl 0xc(%rdi), %ecx
cmpl %esi, %ecx
jg 0x2e26
subl %ecx, %esi
addl 0x8(%rdi), %esi
movl %esi, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/processtab/processtab.c
// Function: printHelp
static void
printHelp()
	{
	printf("Usage: %s [OPTION]... [FILE]\n", programCmdLine);
	printVersion();
    printf("\n");
    printf("FILE argument is mandatory, or must be omitted with option -i.\n");
    printf("  -h           print this help information\n");
    printf("  -i           input from stdin (output default name is 'song.c')\n");
    printf("  -m           output makefile to stdout (cannot be used with -o or -s)\n");
    printf("  -n NAME      set program name for the output\n");
    printf("  -o           output songlib program to stdout\n");
    printf("  -s           skip makefile output (cannot be used with -m)\n");
    printf("  -v           output version information and exit\n");
    printf("  -V VERSION   set program version for the output\n");
	}

// Assembly:
pushq %rax
movq 0x672c(%rip), %rsi      # 0x9170
leaq 0x2759(%rip), %rdi      # 0x51a4
xorl %eax, %eax
callq 0x10a0
callq 0x2a20
pushq $0xa
popq %rdi
callq 0x1040
leaq 0x3197(%rip), %rdi      # 0x5bfd
callq 0x1060
leaq 0x31ca(%rip), %rdi      # 0x5c3c
callq 0x1060
leaq 0x31e9(%rip), %rdi      # 0x5c67
callq 0x1060
leaq 0x321f(%rip), %rdi      # 0x5ca9
callq 0x1060
leaq 0x325b(%rip), %rdi      # 0x5cf1
callq 0x1060
leaq 0x327e(%rip), %rdi      # 0x5d20
callq 0x1060
leaq 0x32a2(%rip), %rdi      # 0x5d50
callq 0x1060
leaq 0x32d3(%rip), %rdi      # 0x5d8d
callq 0x1060
leaq 0x32fa(%rip), %rdi      # 0x5dc0
popq %rax
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/processtab/tabparser.c
// Function: parseTab
ASTTab *
parseTab(FILE *in)
    {
    ASTTab *t = newASTTab();
    ASTCommand *c;
    char ch;
    int i = 0;

    while ((ch = peekChar(in)) && ch != EOF)
        {
        i++;
        /* comment or empty line */
        if (ch == '#' || ch == '\n') 
            {
            while ((ch = fgetc(in)) && ch != '\n' && ch != EOF)
                {
//printf("[parseTab] consumed character '%s'\n", ch == EOF ? "EOF" : ch == '\n' ? "\\n" : "unknown char");
                /* consume */
                }
            continue;
            }
//printf("[parseTab] parsing command\n");
        c = parseCommand(in);
        if (c == 0) return 0;
        addASTCommandToASTTab(c, t);
        }
//printf("[parseTab] ended with character '%s'\n", ch == EOF ? "EOF" : ch == '\n' ? "\\n" : "unknown char");
        
    return t;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2acc
movq %rax, %rbx
movq %r14, %rdi
callq 0x2bfa
leal -0x1(%rax), %ecx
cmpb $-0x3, %cl
ja 0x2beb
cmpb $0x23, %al
je 0x2b71
movzbl %al, %eax
cmpl $0xa, %eax
jne 0x2b8e
movq %r14, %rdi
callq 0x10e0
movzbl %al, %eax
testb %al, %al
je 0x2b51
cmpl $0xa, %eax
je 0x2b51
cmpl $0xff, %eax
jne 0x2b71
jmp 0x2b51
movq %r14, %rdi
callq 0x2c1b
testq %rax, %rax
je 0x2be9
movq %rax, %r15
movq (%rbx), %r12
movl 0x8(%rbx), %eax
leal 0x8(,%rax,8), %edi
callq 0x47c5
movq %rax, (%rbx)
movslq 0x8(%rbx), %rax
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x2bd8
movq (%r12,%rdx,8), %rsi
movq (%rbx), %rdi
movq %rsi, (%rdi,%rdx,8)
incq %rdx
jmp 0x2bc3
movq (%rbx), %rcx
movq %r15, (%rcx,%rax,8)
incl %eax
movl %eax, 0x8(%rbx)
jmp 0x2b51
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/processtab/tabparser.c
// Function: parseCommand
ASTCommand *
parseCommand(FILE *in)
    {
    ASTCommand *c = newASTCommand();
    char ch;
    ASTAttribute *a = 0;
    ASTStave *s = 0;
    char *comment = 0;
    
    while ((ch = peekChar(in)) && ch != EOF && ch != '\n')
        {
    //printf("[parseCommand] read character: '%c'\n", ch);   
        if (ch == '|')
            {  
            s = parseStave(in);
            if (s == 0) return 0;
            
            c->commandType = StaveCommand;
            c->un.stave = s;
            }
        else if (ch == '#')
            {  
            comment = parseComment(in);
            if (comment == 0) return 0;
            
            c->commandType = CommentCommand;
            c->un.comment = comment;
            }
        else if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_')
            {
            a = parseAttribute(in);  
            if (a == 0) return 0;
            
            c->commandType = AttributeCommand;
            c->un.attribute = a;
            break;
            }   
        else if (isspace(ch))
            {
            skipWhiteSpace(in);
            }
        else
            {
            Fatal("unexpected character '%c' reading beginning of line\n");
            return 0;
            }                 
        }
//printf("[parseCommand] consumed character '%s'\n", ch == EOF ? "EOF" : ch == '\n' ? "\\n" : "unknown char");
    
    return c;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x2adf
movq %rax, %rbx
movq %r14, %rdi
callq 0x2bfa
cmpb $0x23, %al
je 0x2c91
movl %eax, %r15d
movzbl %al, %eax
cmpl $0x7c, %eax
je 0x2caa
testl %eax, %eax
je 0x2cf3
cmpl $0xa, %eax
je 0x2cf3
cmpl $0xff, %eax
je 0x2cf3
leal -0x61(%r15), %eax
cmpb $0x1a, %al
jb 0x2cc6
cmpb $0x5f, %r15b
je 0x2cc6
leal -0x41(%r15), %eax
cmpb $0x19, %al
jbe 0x2cc6
callq 0x11d0
movq (%rax), %rax
movsbq %r15b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x2ce3
movq %r14, %rdi
callq 0x30af
jmp 0x2c2b
movq %r14, %rdi
callq 0x2ed7
testq %rax, %rax
je 0x2cdf
movl $0x3, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x2c2b
movq %r14, %rdi
callq 0x2cfc
testq %rax, %rax
je 0x2cdf
movl $0x2, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x2c2b
movq %r14, %rdi
callq 0x2f4c
testq %rax, %rax
je 0x2cdf
movl $0x1, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x2cf3
xorl %ebx, %ebx
jmp 0x2cf3
leaq 0x3108(%rip), %rdi      # 0x5df2
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4610
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/processtab/tabparser.c
// Function: parseComment
char *
parseComment(FILE *in)
    {
    char ch;
    char buffer[COMMENT_LENGTH_MAX];
    int index = 0;
    
    while ((ch = peekChar(in)) && ch != '\n' && ch != EOF)
        {
        if (index == COMMENT_LENGTH_MAX - 1)
            {
            Fatal("Comment string cannot be longer than %i characters\n", COMMENT_LENGTH_MAX - 1);
            return 0;
            }
        ch = fgetc(in);
        buffer[index++] = ch;
        }
    return StringDup(buffer);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x2bfa
testb %al, %al
je 0x2f1c
movzbl %al, %eax
cmpl $0xa, %eax
je 0x2f1c
cmpl $0xff, %eax
je 0x2f1c
cmpq $0xfff, %r14            # imm = 0xFFF
je 0x2f29
movq %rbx, %rdi
callq 0x10e0
movb %al, (%rsp,%r14)
incq %r14
jmp 0x2ee7
movq %rsp, %rdi
callq 0x47a8
movq %rax, %rbx
jmp 0x2f3e
leaq 0x32fd(%rip), %rdi      # 0x622d
xorl %ebx, %ebx
movl $0xfff, %esi            # imm = 0xFFF
xorl %eax, %eax
callq 0x4610
movq %rbx, %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/processtab/tabparser.c
// Function: trimWhiteSpace
static char *
trimWhiteSpace(char *str)
    {
    int frontIndex = 0;
    int backIndex = 0;
    char ch;
    char *newString;
    int i;
    
    if (str == 0) return 0;
    
    while ((ch = str[backIndex]) && ch != '\0' && isspace(ch))
        {
        frontIndex++;
        backIndex++;
        }
        
    if (ch == '\0') return "";
        
    backIndex++;
        
    while ((ch = str[backIndex]) && ch != '\0')
        {
        backIndex++;
        }

    while ((ch = str[backIndex-1]) && isspace(ch) && backIndex > frontIndex)
        {
        backIndex--;
        }
    newString  = (char *)New(sizeof(char) * (backIndex-frontIndex));
    
    for (i = 0; i < backIndex - frontIndex; i++)
        {
        newString[i] = str[frontIndex + i];
        }
    
    newString[backIndex - frontIndex] = '\0';
    return newString;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x313d
movq %rdi, %rbx
xorl %r13d, %r13d
leaq 0x206d(%rip), %r14      # 0x5178
movabsq $0x100000000, %r15      # imm = 0x100000000
xorl %r12d, %r12d
movsbq (%rbx,%r12), %rbp
testq %rbp, %rbp
je 0x31b6
callq 0x11d0
movq (%rax), %rax
testb $0x20, 0x1(%rax,%rbp,2)
je 0x3142
incq %r12
addq %r15, %r13
jmp 0x3118
xorl %r14d, %r14d
jmp 0x31b6
leaq 0x1(%r12), %rcx
xorl %r15d, %r15d
leaq (%rbx,%r15), %rdx
incq %r15
cmpb $0x0, 0x1(%r12,%rdx)
jne 0x314a
sarq $0x20, %r13
movslq %ecx, %rcx
leaq (%rbx,%rcx), %rdx
addq $-0x2, %rdx
decq %rcx
movsbq (%rdx,%r15), %rsi
testq %rsi, %rsi
je 0x318a
testb $0x20, 0x1(%rax,%rsi,2)
je 0x318a
leaq (%rcx,%r15), %rsi
cmpq %r13, %rsi
jle 0x318a
decq %r15
jmp 0x316b
movl %r15d, %edi
callq 0x47c5
movq %rax, %r14
movslq %r15d, %rax
movl %r12d, %ecx
addq %rcx, %rbx
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x31b1
movb (%rbx,%rcx), %dl
movb %dl, (%r14,%rcx)
incq %rcx
jmp 0x31a0
movb $0x0, (%r14,%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/processtab/tabparser.c
// Function: parseMeasure
ASTMeasure *
parseMeasure(FILE *in)
    {
    ASTMeasure *m = newASTMeasure();
    char ch;
    char buffer[AST_MEASURE_LENGTH_MAX];
    int index = 0;
    
    while ((ch = fgetc(in)) && ch != '|')
        {
            if (index == AST_MEASURE_LENGTH_MAX - 1)
                {
                Fatal("measure cannot be longer than %i characters\n", AST_MEASURE_LENGTH_MAX - 1);
                return 0;
                }
            if (ch == EOF)
                {
                Fatal("unexpected EOF reading measure (ensure last character on the line is '|')\n");
                return 0;
                }
            if (ch == '\n')
                {
                Fatal("unexpected newline reading measure (ensure last character on the line is '|')\n");
                return 0;
                }

            buffer[index++] = ch;
        }
        
    buffer[index] = '\0';
    m->events = StringDup(buffer);
    
    return m;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %r14
callq 0x2b2f
movq %rax, %rbx
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x10e0
movl %eax, %ecx
shll $0x18, %ecx
je 0x3535
cmpl $0x7c000000, %ecx       # imm = 0x7C000000
je 0x3535
cmpq $0x3ff, %r15            # imm = 0x3FF
je 0x3547
cmpl $0xa000000, %ecx        # imm = 0xA000000
je 0x355e
cmpl $0xff000000, %ecx       # imm = 0xFF000000
je 0x3567
movb %al, (%rsp,%r15)
incq %r15
jmp 0x34fc
movb $0x0, (%rsp,%r15)
movq %rsp, %rdi
callq 0x47a8
movq %rax, (%rbx)
jmp 0x3577
leaq 0x2c18(%rip), %rdi      # 0x6166
xorl %ebx, %ebx
movl $0x3ff, %esi            # imm = 0x3FF
xorl %eax, %eax
callq 0x4610
jmp 0x3577
leaq 0x2c79(%rip), %rdi      # 0x61de
jmp 0x356e
leaq 0x2c25(%rip), %rdi      # 0x6193
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4610
movq %rbx, %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/processtab/tabparser.c
// Function: indent
void
indent(FILE *out)
	{
    int i;
    if (indentLevel < 0)
    	{
    	Fatal("indentLevel less than zero, actual value: %i\n", indentLevel);
    	return;
    	}
    for (i = 0; i < indentLevel; i++)
        {
        fprintf(out, "    ");        
        }
    }

// Assembly:
movl 0x578c(%rip), %esi      # 0x917c
testl %esi, %esi
js 0x3a38
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x2995(%rip), %r14      # 0x639d
pushq $0x4
popq %r15
pushq $0x1
popq %r12
cmpl %esi, %ebp
jge 0x3a2f
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x11c0
incl %ebp
movl 0x574f(%rip), %esi      # 0x917c
jmp 0x3a10
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2930(%rip), %rdi      # 0x636f
xorl %eax, %eax
jmp 0x4610
nop
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: concatDoubleArrays
static DoubleArray *
concatDoubleArrays(DoubleArray *first, DoubleArray *second)
    {
//printf("[concatDoubleArrays]\n");
    DoubleArray *newArray;
    int i, firstLength = 0, secondLength = 0;
    
    if (first == 0 && second == 0) return 0;
    
//printf("[concatDoubleArrays] first: {%zu}\n", (size_t)first);
//printf("[concatDoubleArrays] second: {%zu}\n", (size_t)second);
    
    if (first == 0) firstLength = 0;
    else firstLength = first->length;

    if (second == 0) secondLength = 0;
    else secondLength = second->length;
        
//printf("[concatDoubleArrays] firstLength: %i\n", firstLength);
//printf("[concatDoubleArrays] secondLength: %i\n", secondLength);
    
    newArray = newDoubleArray(firstLength + secondLength);
        
    for (i = 0; i < firstLength; i++)
        {
        newArray->values[i] = first->values[i];
        }
    for (i = 0; i < secondLength; i++)
        {
        newArray->values[firstLength + i] = second->values[i];
        }
//printf("[concatDoubleArrays] newArray: {%zu}\n", (size_t)newArray);
//printf("[concatDoubleArrays] newArray->length: %i\n", newArray->length);
    return newArray;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %r12d, %r12d
movq %rdi, %rax
orq %rsi, %rax
jne 0x43bb
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x43ca
movl 0x8(%r14), %r12d
xorl %r13d, %r13d
movl $0x0, %r15d
testq %rbx, %rbx
je 0x43dc
movl 0x8(%rbx), %r15d
leal (%r15,%r12), %edi
callq 0x44eb
testl %r12d, %r12d
movl $0x0, %ecx
cmovgl %r12d, %ecx
cmpq %r13, %rcx
je 0x440d
movq (%r14), %rdx
movsd (%rdx,%r13,8), %xmm0
movq (%rax), %rdx
movsd %xmm0, (%rdx,%r13,8)
incq %r13
jmp 0x43f1
movslq %r12d, %rcx
xorl %edx, %edx
testl %r15d, %r15d
cmovlel %edx, %r15d
shlq $0x3, %rcx
cmpq %rdx, %r15
je 0x43b1
movq (%rbx), %rsi
movsd (%rsi,%rdx,8), %xmm0
movq (%rax), %rsi
addq %rcx, %rsi
movsd %xmm0, (%rsi,%rdx,8)
incq %rdx
jmp 0x441d
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: newStringArray
static StringArray *
newStringArray(int size)
    {
    StringArray *sa = (StringArray *) New(sizeof(StringArray));
    int i;
    
    sa->values = (char **) New(sizeof(char *) * size);
    sa->length = size;
    for (i=0; i<size; i++)
        {
        sa->values[i] = 0;
        }
    return sa;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x10
popq %rdi
callq 0x47c5
movq %rax, %r14
leal (,%rbx,8), %edi
callq 0x47c5
movq %rax, (%r14)
movl %ebx, 0x8(%r14)
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
cmpq %rax, %rbx
je 0x4477
movq (%r14), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x4465
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: substring
static char *
substring(const char* str, size_t begin, size_t len)
    {
    int strLength;
    int realLength = len;
    
//printf("[substring] 1\n");
    if (str == 0)
        {
        return 0;
        }
        
    strLength = strlen(str);
//printf("[substring] 2\n");
        
    if (len == 0 || strLength == 0 || strLength < begin)
        {
        return StringDup("");
        }
        
//printf("[substring] 3\n");
    if (strLength < (begin+len))
        {
        realLength = strLength - begin;
        }

//printf("[substring] 4\n");
    return strndup(str + begin, realLength);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x44c2
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1080
testq %r15, %r15
sete %cl
testl %eax, %eax
sete %dl
orb %cl, %dl
jne 0x44b1
movslq %eax, %rcx
cmpq %r14, %rcx
jae 0x44ca
leaq 0xcc0(%rip), %rdi       # 0x5178
popq %rbx
popq %r14
popq %r15
jmp 0x47a8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq (%r15,%r14), %rdx
subl %r14d, %eax
cmpq %rdx, %rcx
cmovaeq %r15, %rax
addq %r14, %rbx
movslq %eax, %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: newDoubleArray
static DoubleArray *
newDoubleArray(int size)
    {
    DoubleArray *da = (DoubleArray *) New(sizeof(DoubleArray));
    int i;
    
    da->values = (double *) New(sizeof(double) * size);
    da->length = size;
    for (i=0; i<size; i++)
        {
        da->values[i] = 0;
        }
    return da;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x10
popq %rdi
callq 0x47c5
movq %rax, %r14
leal (,%rbx,8), %edi
callq 0x47c5
movq %rax, (%r14)
movl %ebx, 0x8(%r14)
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x4525
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0x4516
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: cons_str
static char *
cons_str(char car, char *cdr)
    {
    int i, newLength = strlen(cdr) + 2;
    
    char *newString = (char *)New(sizeof(char) * newLength);
    newString[0] = car;
    
    for (i = 1; i < newLength; i++)
        {
        newString[i] = cdr[i-1];
        }
	newString[newLength - 1] = '\0';
    return newString;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq %rsi, %rdi
callq 0x1080
movq %rax, %r14
movl %r14d, %r15d
addl $0x2, %r15d
movl %r15d, %edi
callq 0x47c5
movb %bpl, (%rax)
movslq %r15d, %rcx
pushq $0x1
popq %rdx
cmpq %rcx, %rdx
jge 0x4572
movb -0x1(%rbx,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
jmp 0x455f
leal 0x1(%r14), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: parseGenericTimingEvents
static DoubleArray *
parseGenericTimingEvents(char *timingEvents, double totalValue)
    {
//printf("[parseGenericTimingEvents]\n");
    int length = strlen(timingEvents);
    DoubleArray *retVal = newDoubleArray(length);
    int i;
    char ch;
    
    for (i = 0; i < length; i++)
        {
        ch = timingEvents[i];
        /* expect only spaces and dots after first event */
        if (ch != '.' && i != 0)
            {
            Fatal("Timing '.' expected; found '%c'\n", timingEvents[i]);
            return 0;
            }
        retVal->values[i] = totalValue / length;
//printf("[parseGenericTimingEvents] Converted '%c' into duration: %f\n", timingEvents[i], retVal->values[i]);
        }
//printf("[parseGenericTimingEvents] retVal length: %i\n", retVal->length);
    return retVal;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
callq 0x1080
movq %rax, %r15
movl %r15d, %edi
callq 0x44eb
movq %rax, %rbx
cvtsi2sd %r15d, %xmm0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %rax, %r15
je 0x4600
movsbl (%r14,%rax), %esi
cmpl $0x2e, %esi
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x45f0
movq (%rbx), %rcx
movsd %xmm0, (%rcx,%rax,8)
incq %rax
jmp 0x45c9
leaq 0x1e58(%rip), %rdi      # 0x644f
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x4610
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x2430, %rsp           # imm = 0x2430
cmpl $0x2, %edi
jl 0x128f
movq 0x8(%rsi), %rbx
jmp 0x1296
leaq 0x2d6e(%rip), %rbx      # 0x4004
movq %rbx, %rdi
callq 0x2eef
callq 0x2e92
callq 0x2780
movq %rbx, %rdi
callq 0x1854
leaq 0x2d55(%rip), %rdx      # 0x400c
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x1a70
testl %eax, %eax
js 0x12d6
leaq 0x8(%rsp), %rdi
callq 0x1bb8
xorl %eax, %eax
jmp 0x12d9
pushq $0x1
popq %rax
addq $0x2430, %rsp           # imm = 0x2430
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
leaq 0x2d22(%rip), %rsi      # 0x4011
callq 0x1140
testq %rax, %rax
je 0x1302
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1315
callq 0x1060
movl (%rax), %edi
callq 0x1170
movq %rax, (%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0x12e4
testq %rax, %rax
je 0x1871
addq $0x10, %rsp
popq %rbx
retq
movq 0x8(%rsp), %rdx
leaq 0x2797(%rip), %rdi      # 0x4014
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10c0
pushq $0x1
popq %rdi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5878(%rip), %rdi      # 0x7118
movq %r14, %rsi
callq 0x2b6f
testq %rax, %rax
je 0x18b8
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
callq 0x2f1f
testq %rax, %rax
je 0x18d7
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1315
leaq 0x273e(%rip), %rax      # 0x401c
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x18b0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0x188f
testq %rax, %rax
je 0x1902
addq $0x10, %rsp
popq %rbx
retq
movq 0x56e7(%rip), %rax      # 0x6ff0
movq (%rax), %rdi
movq 0x8(%rsp), %rcx
leaq 0x26fc(%rip), %rsi      # 0x4014
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movzbl 0x18(%rdi), %r12d
cmpb %r14b, %r12b
jbe 0x196f
movzbl %r14b, %esi
addq 0x60(%r15), %rsi
movq %rbx, %rdi
callq 0x10f0
testl %eax, %eax
je 0x1995
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x19a4
movq 0x10(%r15), %rax
movzwl (%rax,%r14,4), %esi
addq 0x60(%r15), %rsi
movq %rbx, %rdi
callq 0x10f0
testl %eax, %eax
je 0x1995
incq %r14
jmp 0x1972
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x5645(%rip), %rax      # 0x6ff0
movq (%rax), %rdi
movq (%r15), %rdx
leaq 0x2678(%rip), %rsi      # 0x4030
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1150
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x1940
movq 0x10(%r14), %rcx
movq 0x20(%r14), %rdx
movzbl %al, %eax
movzbl 0x2(%rcx,%rax,4), %eax
imulq $0xc, %rax, %rax
leaq (%rdx,%rax), %rcx
movl (%rdx,%rax), %eax
addq 0x50(%r14), %rax
movq %rax, 0x2420(%rbx)
movq %rbx, 0x2000(%rbx)
leaq 0x1ffc(%rbx), %rax
movq %rax, 0x2008(%rbx)
leaq 0x2010(%rbx), %rax
leaq 0x26f4(%rip), %rdx      # 0x41c4
movq %rdx, 0x2020(%rbx)
movq %rcx, 0x2018(%rbx)
movq %r14, 0x2010(%rbx)
movq %rax, 0x2410(%rbx)
leaq 0x23f0(%rbx), %rax
movq %rax, 0x2418(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x20(%rsi), %r8
movl %edx, %eax
imulq $0xc, %rax, %rdx
movq 0x2410(%rdi), %rcx
movq 0x8(%rcx), %rax
movzbl 0xa(%rax), %r10d
movzbl 0xb(%rax), %r9d
addq %r10, %r9
movzbl 0xa(%r8,%rdx), %eax
subq %rax, %r9
shlq $0x2, %r9
addq 0x2000(%rdi), %r9
movq %r9, 0x2000(%rdi)
pushq $-0x1
popq %rax
cmpq 0x2008(%rdi), %r9
ja 0x1b8b
leaq 0x20(%rcx), %r10
movq %r10, 0x2410(%rdi)
cmpq 0x2418(%rdi), %r10
ja 0x1b8b
addq %rdx, %r8
movq %r8, 0x28(%rcx)
movq %r9, 0x38(%rcx)
movq 0x2420(%rdi), %rax
movq %rax, 0x30(%rcx)
movl (%r8), %eax
addq 0x50(%rsi), %rax
movq %rax, 0x2420(%rdi)
movq %rsi, 0x20(%rcx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x516f(%rip), %rax      # 0x7920
movl %edi, (%rax)
movslq %edi, %rcx
addq %rax, %rcx
movq %rcx, 0x5160(%rip)      # 0x7920
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %r14d
movl %r14d, %edi
callq 0x2806
movq %rax, %r15
leaq 0x8(%rax), %rdi
addq $0x4, %rbx
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1110
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movzbl 0x80(%rdi), %edi
addl $0x10, %edi
callq 0x27aa
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
movq %rdi, %r14
callq 0x2848
movl %eax, %ebp
movq %r14, %rdi
callq 0x289e
movq %rax, %r15
xorl %r12d, %r12d
leaq 0x43be(%rip), %rbx      # 0x6cd0
cmpq $0x10, %r12
je 0x293a
movq (%r12,%rbx), %r13
movslq 0x8(%r13), %rdx
cmpl %ebp, %edx
jg 0x2934
movq (%r13), %rsi
movq %r15, %rdi
callq 0x1130
testl %eax, %eax
je 0x2941
addq $0x8, %r12
jmp 0x2912
leaq 0x439f(%rip), %r13      # 0x6ce0
movq %r14, %rdi
callq 0x289e
movq %rax, %r15
movq %r14, %rdi
callq 0x2848
movslq 0x8(%r13), %rcx
addq %rcx, %r15
subl %ecx, %eax
incl %eax
movslq %eax, %r14
movq %r14, %rdi
callq 0x1120
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1110
movb $0x0, (%r12,%r14)
movzbl 0x4(%rsp), %esi
movq %r12, %rdi
callq *0x10(%r13)
movq %rax, %rbx
movq %r12, %rdi
callq 0x1040
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
decb %sil
cmpb $0x2, %sil
ja 0x2a80
pushq %rbx
movzbl %sil, %eax
leaq 0x17e1(%rip), %rcx      # 0x4234
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
callq 0x1140
testq %rax, %rax
je 0x2a83
movq %rax, %rbx
pushq $0x18
popq %rdi
callq 0x27aa
movq %rbx, 0x10(%rax)
leaq 0x42ae(%rip), %rcx      # 0x6d28
movq %rcx, 0x8(%rax)
jmp 0x2a85
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x10a0
movq %rax, %r14
movslq %r14d, %r15
leaq 0x42ae(%rip), %r12      # 0x6d58
movq (%r12), %rax
testq %rax, %rax
je 0x2af8
cmpl %r14d, -0x10(%r12)
jne 0x2ad1
movq -0x18(%r12), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %rax, %r13
callq 0x1130
testl %eax, %eax
je 0x2ad7
addq $0x20, %r12
jmp 0x2aaa
movzbl %bpl, %eax
testl %eax, -0x8(%r12)
je 0x2af8
movq %r13, %rcx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x27aa
movq %rbx, 0x10(%rax)
leaq 0x427c(%rip), %rcx      # 0x6dc0
movq %rcx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
cmpq $0x100, %rax            # imm = 0x100
je 0x2b60
andq $0x0, (%rdi,%rax,8)
incq %rax
jmp 0x2b4e
andl $0x0, 0x800(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2ba3
movzbl %al, %eax
leaq (%r14,%rax,8), %rdi
movq %rbx, %rsi
callq 0x2bb3
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
movb (%rdi), %cl
testb %cl, %cl
je 0x2bb2
addb %cl, %al
incq %rdi
jmp 0x2ba5
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2ba3
movzbl %al, %eax
leaq (%r14,%rax,8), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2bb3
testq %rax, %rax
je 0x2c17
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2c27
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x44a4(%rip), %rax      # 0x70e0
testq %rax, %rax
je 0x2c68
movq (%rax), %rcx
movq %rcx, 0x4495(%rip)      # 0x70e0
movq %r15, (%rax)
movq (%r14), %rcx
movq %rcx, 0x10(%rax)
movq %rax, (%r14)
incl 0x800(%rbx)
addq $0x8, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4471(%rip), %rdi      # 0x70e0
callq 0x2d4c
movq 0x4465(%rip), %rax      # 0x70e0
jmp 0x2c41
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2ba3
movzbl %al, %eax
leaq (%r14,%rax,8), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2bb3
testq %rax, %rax
je 0x2cb1
addq $0x8, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2c27
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
cmpq $0x100, %rax            # imm = 0x100
je 0x2cfb
movq (%rdi,%rax,8), %rcx
testq %rcx, %rcx
je 0x2cf6
movq 0x4402(%rip), %rdx      # 0x70e0
movq %rdx, (%rcx)
movq (%rdi,%rax,8), %rcx
movq %rcx, 0x43f4(%rip)      # 0x70e0
movq 0x10(%rcx), %rcx
movq %rcx, (%rdi,%rax,8)
jmp 0x2cd2
incq %rax
jmp 0x2cc6
andl $0x0, 0x800(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
cmpq $0x100, %r15            # imm = 0x100
je 0x2d40
leaq (%r14,%r15,8), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x2d3b
movq (%r12), %rdi
leaq 0x8(%r12), %rsi
callq *%rbx
addq $0x10, %r12
jmp 0x2d21
incq %r15
jmp 0x2d14
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/lib/mm.c
// Function: mm_pool_alloc
void mm_pool_alloc(struct mm_pool_struct *pool)
{
	const unsigned size = pool->el_size;
	unsigned poolsize = pool->size;
	char *mem = malloc(size * poolsize);
#ifdef TEST
	++alloc_count;
#endif
	if(unlikely(mem == NULL)) {
		poolsize = MM_MIN_SIZE;
		mem = malloc(size * MM_MIN_SIZE);
		if(unlikely(mem == NULL)) {
			if(mm_on_error)
				mem = mm_on_error(pool);
			else {
				fputs(__FILE__ ": ERROR: Out of memory", stderr);
				exit(1);
			}
		}
	}

	pool->head = mem;
	for(--poolsize; poolsize != 0; --poolsize, mem += size)
		*(void **)mem = mem + size;
	*(void **)mem = NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movl 0xc(%rdi), %r14d
movl %r14d, %edi
imull %ebp, %edi
callq 0x1120
testq %rax, %rax
je 0x2d89
movq %rax, (%rbx)
decl %ebp
subl $0x1, %ebp
jb 0x2d80
leaq (%rax,%r14), %rcx
movq %rcx, (%rax)
movq %rcx, %rax
jmp 0x2d6f
andq $0x0, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
leal (,%r14,4), %edi
callq 0x1120
pushq $0x4
popq %rbp
testq %rax, %rax
jne 0x2d6a
movq 0x4b8b(%rip), %rax      # 0x7930
testq %rax, %rax
je 0x2db1
movq %rbx, %rdi
callq *%rax
jmp 0x2d6a
movq 0x4238(%rip), %rax      # 0x6ff0
movq (%rax), %rsi
leaq 0x1495(%rip), %rdi      # 0x4257
callq 0x10e0
pushq $0x1
popq %rdi
callq 0x1150
nop
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/lib/loader.c
// Function: add
static int add(const char *path, int length)
{
	StdPath *sp;
	if(length == 0 || length > 255)
		return 0;
	sp = mm_alloc(StdPath);
	sp->length = length;
	memcpy(sp->buffer, path, length);
	if(path[length - 1] != '/')
		sp->buffer[sp->length++] = '/';
	SIMPLEQ_INSERT_TAIL(&stdpath_list, sp, pe);
	return 1;
}

// Assembly:
testl %esi, %esi
sete %cl
cmpl $0x100, %esi            # imm = 0x100
setge %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x2e7c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x42f3(%rip), %r12      # 0x7100
testq %r12, %r12
je 0x2e7d
movq (%r12), %rax
movq %rax, 0x42e3(%rip)      # 0x7100
movb %bl, (%r12)
leaq 0x1(%r12), %rdi
movslq %ebx, %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x1110
cmpb $0x2f, -0x1(%r14,%r15)
je 0x2e4c
leal 0x1(%rbx), %eax
movb %al, (%r12)
movzbl %bl, %eax
movb $0x2f, 0x1(%r12,%rax)
leaq 0x108(%r12), %rax
andq $0x0, 0x108(%r12)
movq 0x4294(%rip), %rcx      # 0x70f8
movq %r12, (%rcx)
movq %rax, 0x428a(%rip)      # 0x70f8
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x427c(%rip), %rdi      # 0x7100
callq 0x2d4c
movq 0x4270(%rip), %r12      # 0x7100
jmp 0x2e12
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/lib/loader.c
// Function: loader_add_dirs_from_env
void loader_add_dirs_from_env()
{
	const char *rosepath = getenv("ROSEPATH");
	if(rosepath) {
		const char *start, *end;
		for(start = rosepath, end = strchr(rosepath, ':'); end;
				start = end + 1, end = strchr(start, ':')) {
			add(start, end - start);
		}
		add(start, strlen(start));
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x13d5(%rip), %rdi      # 0x4272
callq 0x1030
testq %rax, %rax
je 0x2eea
movq %rax, %rbx
pushq $0x3a
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x10b0
testq %rax, %rax
je 0x2ed4
movq %rax, %r14
movl %r14d, %esi
subl %ebx, %esi
movq %rbx, %rdi
callq 0x2de1
incq %r14
movq %r14, %rbx
jmp 0x2ead
movq %rbx, %rdi
callq 0x10a0
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x2de1
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/lib/loader.c
// Function: loader_add_dir_from_file
int loader_add_dir_from_file(const char *fname)
{
	const char *slash = strrchr(fname, '/');
	return slash ?
		add(fname, slash - fname + 1) : /* cut out last path component */
		add("./", 2);                   /* use current directory */
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x2f
popq %rsi
callq 0x10d0
testq %rax, %rax
je 0x2f0f
subl %ebx, %eax
incl %eax
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
jmp 0x2de1
leaq 0x1365(%rip), %rdi      # 0x427b
pushq $0x2
popq %rsi
popq %rbx
jmp 0x2de1
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/lib/loader.c
// Function: loader_find_module
FILE *loader_find_module(Symbol *name)
{
	StdPath *ent;
	const int flen = strlen(name);
	SIMPLEQ_FOREACH(ent, &stdpath_list, pe) {
		FILE *f;
		static const char suffix[] = ".rmd";
		char *const buf = ent->buffer;
		const int dlen = ent->length;
		const int len = dlen + flen;
		if(len + sizeof suffix > 255)
			continue;
		strcpy(buf + dlen, name);
		memcpy(buf + len, suffix, sizeof suffix);
		f = fopen(buf, "rb");
		if(f)
			return f;
	}
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x10a0
movq %rax, %r15
leaq 0x41b4(%rip), %rbp      # 0x70f0
leaq 0x10ce(%rip), %r12      # 0x4011
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x2fa2
movzbl (%rbp), %eax
leal (%r15,%rax), %ecx
movslq %ecx, %r14
leaq -0xfb(%r14), %rcx
cmpq $-0x100, %rcx
jb 0x2f99
leaq 0x1(%rbp), %r13
leaq (%rax,%rbp), %rdi
incq %rdi
movq %rbx, %rsi
callq 0x1070
movl $0x646d722e, 0x1(%rbp,%r14) # imm = 0x646D722E
movb $0x0, 0x5(%rbp,%r14)
movq %r13, %rdi
movq %r12, %rsi
callq 0x1140
testq %rax, %rax
jne 0x2fa4
addq $0x108, %rbp            # imm = 0x108
jmp 0x2f43
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/almk277[P]ROSE/lib/loader.c
// Function: loader_print_pathes
void loader_print_pathes()
{
	StdPath *ent;
	SIMPLEQ_FOREACH(ent, &stdpath_list, pe) {
		fwrite(ent->buffer, ent->length, 1, stdout);
		putchar('\n');
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x412f(%rip), %r14      # 0x70f0
movq 0x4000(%rip), %r15      # 0x6fc8
pushq $0x1
popq %rbx
pushq $0xa
popq %rbp
movq (%r14), %r14
testq %r14, %r14
je 0x2ff9
leaq 0x1(%r14), %rdi
movzbl (%r14), %esi
movq (%r15), %rcx
movq %rbx, %rdx
callq 0x1160
movl %ebp, %edi
callq 0x1050
addq $0x108, %r14            # imm = 0x108
jmp 0x2fce
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_ub_test_default.c
// Function: thread_func_push
int thread_func_push(void *ctx)
{
	struct spsc_ub_queue *q = (struct spsc_ub_queue *) ctx;

	srand((unsigned) time(0) + thread_get_id());
	size_t pause = rand() % 1000;

	/* Wait for global start signal */
	while (g_start == 0)
		thrd_yield();

	/* Wait for a random time */
	for (size_t i = 0; i != pause; i += 1)
		nop();

	for (int iter = 0; iter != iter_count; ++iter) {
		for (size_t i = 0; i != batch_size; i += 1) {
			void *ptr = (void *) i;
			spsc_ub_queue_push(q, ptr);	//FIXME
		}
	}
	thrd_yield();

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
callq 0x1090
leal -0x1(%rax), %edi
callq 0x1080
callq 0x10f0
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %edx, %ebp
cmpl $0x0, 0x2e65(%rip)      # 0x4094
jne 0x1238
callq 0x1070
jmp 0x1228
movslq %ebp, %rax
subq $0x1, %rax
jb 0x1245
pause
jmp 0x123b
xorl %r15d, %r15d
cmpl $0x1312d00, %r15d       # imm = 0x1312D00
je 0x126f
xorl %r14d, %r14d
cmpq $0xa, %r14
je 0x126a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14a1
incq %r14
jmp 0x1254
incl %r15d
jmp 0x1248
callq 0x1070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_ub_test_default.c
// Function: thread_func_pull
int thread_func_pull(void *ctx)
{
	struct spsc_ub_queue *q = (struct spsc_ub_queue *) ctx;

	srand((unsigned) time(0) + thread_get_id());
	size_t pause = rand() % 1000;

	/* Wait for global start signal */
	while (g_start == 0)
		thrd_yield();

	/* Wait for a random time */
	for (size_t i = 0; i != pause; i += 1)
		nop();

	for (int iter = 0; iter != iter_count; ++iter) {
		for (size_t i = 0; i != batch_size; i += 1) {
			void *ptr;
			while (!spsc_ub_queue_pull(q, &ptr)){
				continue;
			}	//FIXME
		}
	}
	thrd_yield(); // queue empty
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x1090
leal -0x1(%rax), %edi
callq 0x1080
callq 0x10f0
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %edx, %ebp
cmpl $0x0, 0x2ddf(%rip)      # 0x4094
jne 0x12be
callq 0x1070
jmp 0x12ae
movslq %ebp, %rax
subq $0x1, %rax
jb 0x12cb
pause
jmp 0x12c1
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
cmpl $0x1312d00, %r15d       # imm = 0x1312D00
je 0x12fe
xorl %r12d, %r12d
cmpq $0xa, %r12
je 0x12f9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14d7
testl %eax, %eax
je 0x12e5
incq %r12
jmp 0x12df
incl %r15d
jmp 0x12d3
callq 0x1070
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq