LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x3230
movq %rax, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34c0
movb %al, -0x21(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x3402
movsbl -0x21(%rbp), %eax
cmpl $-0x1, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x340e
jmp 0x349f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x23, %eax
je 0x3429
movsbl -0x21(%rbp), %eax
cmpl $0xa, %eax
jne 0x346f
jmp 0x342b
movq -0x10(%rbp), %rdi
callq 0x10c0
movb %al, -0x21(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2a(%rbp)
je 0x345f
movsbl -0x21(%rbp), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x2a(%rbp)
je 0x345f
movsbl -0x21(%rbp), %eax
cmpl $-0x1, %eax
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x3468
jmp 0x346a
jmp 0x342b
jmp 0x33dc
movq -0x10(%rbp), %rdi
callq 0x34f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x348d
movq $0x0, -0x8(%rbp)
jmp 0x34a7
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36b0
jmp 0x33dc
movq -0x18(%rbp), %rax
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/pipde[P]deos-songlib/utils/processtab/tabparser.c
// Function: addASTCommandToASTTab
static void
addASTCommandToASTTab(ASTCommand *c, ASTTab *t)
    {    
    int i;
    ASTCommand **oldCommands = t->commands;
    t->commands = (ASTCommand **) New(sizeof(ASTCommand *) * (t->commandCount+1));
    for (i=0;i<t->commandCount;++i)
        {
        t->commands[i] = oldCommands[i];
        }
    t->commands[t->commandCount] = c;
    ++(t->commandCount);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
movl %eax, %edi
callq 0x6630
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x3725
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x36f3
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movl $0x0, -0x1024(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34c0
movb %al, -0x11(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1025(%rbp)
je 0x3a46
movsbl -0x11(%rbp), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x1025(%rbp)
je 0x3a46
movsbl -0x11(%rbp), %eax
cmpl $-0x1, %eax
setne %al
movb %al, -0x1025(%rbp)
movb -0x1025(%rbp), %al
testb $0x1, %al
jne 0x3a52
jmp 0x3aa9
cmpl $0xfff, -0x1024(%rbp)   # imm = 0xFFF
jne 0x3a7b
leaq 0x47e9(%rip), %rdi      # 0x824e
movl $0xfff, %esi            # imm = 0xFFF
movb $0x0, %al
callq 0x63e0
movq $0x0, -0x8(%rbp)
jmp 0x3ab9
movq -0x10(%rbp), %rdi
callq 0x10c0
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %cl
movl -0x1024(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x1024(%rbp)
cltq
movb %cl, -0x1020(%rbp,%rax)
jmp 0x3a09
leaq -0x1020(%rbp), %rdi
callq 0x65f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabparser.c
// Function: addASTCourseToASTStave
static void
addASTCourseToASTStave(ASTCourse *c, ASTStave *s)
    {    
    int i;
    ASTCourse **oldCourses = s->courses;
    s->courses = (ASTCourse **) New(sizeof(ASTCourse *) * (s->courseCount+1));
    for (i=0;i<s->courseCount;++i)
        {
        s->courses[i] = oldCourses[i];
        }
    s->courses[s->courseCount] = c;
    ++(s->courseCount);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
movl %eax, %edi
callq 0x6630
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x4505
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x44d3
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x10(%rbp)
callq 0x3390
movq %rax, -0x18(%rbp)
movl $0x0, -0x424(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10c0
movb %al, -0x19(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x425(%rbp)
je 0x457e
movsbl -0x19(%rbp), %eax
cmpl $0x7c, %eax
setne %al
movb %al, -0x425(%rbp)
movb -0x425(%rbp), %al
testb $0x1, %al
jne 0x458d
jmp 0x461d
cmpl $0x3ff, -0x424(%rbp)    # imm = 0x3FF
jne 0x45b9
leaq 0x3be7(%rip), %rdi      # 0x8187
movl $0x3ff, %esi            # imm = 0x3FF
movb $0x0, %al
callq 0x63e0
movq $0x0, -0x8(%rbp)
jmp 0x464a
movsbl -0x19(%rbp), %eax
cmpl $-0x1, %eax
jne 0x45da
leaq 0x3beb(%rip), %rdi      # 0x81b4
movb $0x0, %al
callq 0x63e0
movq $0x0, -0x8(%rbp)
jmp 0x464a
movsbl -0x19(%rbp), %eax
cmpl $0xa, %eax
jne 0x45fb
leaq 0x3c15(%rip), %rdi      # 0x81ff
movb $0x0, %al
callq 0x63e0
movq $0x0, -0x8(%rbp)
jmp 0x464a
movb -0x19(%rbp), %cl
movl -0x424(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x424(%rbp)
cltq
movb %cl, -0x420(%rbp,%rax)
jmp 0x4552
movslq -0x424(%rbp), %rax
movb $0x0, -0x420(%rbp,%rax)
leaq -0x420(%rbp), %rdi
callq 0x65f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabparser.c
// Function: addASTMeasureToASTCourse
static void
addASTMeasureToASTCourse(ASTMeasure *m, ASTCourse *c)
    {    
    int i;
    ASTMeasure **oldMeasures = c->measures;
    c->measures = (ASTMeasure **) New(sizeof(ASTMeasure *) * (c->measureCount+1));
    for (i=0;i<c->measureCount;++i)
        {
        c->measures[i] = oldMeasures[i];
        }
    c->measures[c->measureCount] = m;
    ++(c->measureCount);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
movl %eax, %edi
callq 0x6630
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x46d8
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x46a5
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x6439(%rip)      # 0xb15c
jge 0x4d3b
movl 0x6431(%rip), %esi      # 0xb15c
leaq 0x365e(%rip), %rdi      # 0x8390
movb $0x0, %al
callq 0x63e0
jmp 0x4d6a
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x6411(%rip), %eax      # 0xb15c
jge 0x4d6a
movq -0x8(%rbp), %rdi
leaq 0x3666(%rip), %rsi      # 0x83be
movb $0x0, %al
callq 0x1100
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4d42
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: newComposition
Composition *
newComposition()
    {
    Composition *c = (Composition *) New(sizeof(Composition));
    
    c->parts = 0;
    c->partCount = 0;
    c->sections = 0;
    c->sectionCount = 0;
    
    return c;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x30, %edi
callq 0x6630
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: newPart
Part *
newPart()
    {
    Part *p = (Part *) New(sizeof(Part));
    
    p->measures = 0;
    p->measureCount = 0;
    p->voiceName = 0;
    p->composition = 0;

    return p;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x6630
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: newMeasure
Measure *
newMeasure()
    {
    Measure *m = (Measure *) New(sizeof(Measure));
    
    m->noteInstances = 0;
    m->noteInstanceCount = 0;
    m->beatsInMeasure = 0;
    m->beatLength = 0;
    m->part = 0;
    
    return m;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x6630
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: newNoteInstance
NoteInstance *
newNoteInstance()
    {
    NoteInstance *ni = (NoteInstance *) New(sizeof(NoteInstance));
    
    ni->noteName = 0;
    ni->duration = 0;
    
    return ni;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x6630
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: newSection
Section *
newSection()
    {
    Section *s = (Section *) New(sizeof(Section));
    
    s->attributes = 0;
    s->attributeCount = 0;
    s->measureNumber = 0;
    s->composition = 0;

    return s;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x6630
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: addPartToComposition
static void
addPartToComposition(Part *p, Composition *c)
    {    
    int i;
    Part **oldParts = c->parts;
    c->parts = (Part **) New(sizeof(Part *) * (c->partCount+1));
    for (i=0;i<c->partCount;++i)
        {
        c->parts[i] = oldParts[i];
        }
    c->parts[c->partCount] = p;
    ++(c->partCount);
    
    p->composition = c;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
movl %eax, %edi
callq 0x6630
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x53b5
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5383
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: addAttributeToList
static ASTAttributeList *
addAttributeToList(ASTAttribute *attribute, ASTAttributeList *attributeList)
    {
    ASTAttributeList *head, *curr, *newAal = newASTAttributeList();    
    newAal->attribute = attribute;
    
    if (attributeList == 0) return newAal;
    
    head = curr = attributeList;
    while (curr != 0 && curr->next != 0)
        {
        curr = curr->next;
        }
    curr->next = newAal;
    return head;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x58a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x5425
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5477
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0x544c
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x5455
jmp 0x5463
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x5431
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: addAttributeNameToComposition
static void
addAttributeNameToComposition(char *an, Composition *c)
    {    
    int i;
    char **oldAttributeNames = c->attributeNames;
    c->attributeNames = (char **) New(sizeof(char *) * (c->attributeNameCount+1));
    for (i=0;i<c->attributeNameCount;++i)
        {
        c->attributeNames[i] = oldAttributeNames[i];
        }
    c->attributeNames[c->attributeNameCount] = an;
    ++(c->attributeNameCount);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
movl %eax, %edi
callq 0x6630
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x5508
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x54d5
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x28(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: addSectionToComposition
static void
addSectionToComposition(Section *s, Composition *c)
    {    
    int i;
    Section **oldSections = c->sections;
    c->sections = (Section **) New(sizeof(Section *) * (c->sectionCount+1));
    for (i=0;i<c->sectionCount;++i)
        {
        c->sections[i] = oldSections[i];
        }
    c->sections[c->sectionCount] = s;
    ++(c->sectionCount);
    
    s->composition = c;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
movl %eax, %edi
callq 0x6630
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x55b8
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5585
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: addMeasureToPart
static void
addMeasureToPart(Measure *m, Part *p)
    {    
    int i;
    Measure **oldMeasures = p->measures;
    p->measures = (Measure **) New(sizeof(Measure *) * (p->measureCount+1));
    for (i=0;i<p->measureCount;++i)
        {
        p->measures[i] = oldMeasures[i];
        }
    p->measures[p->measureCount] = m;
    ++(p->measureCount);
    
    m->part = p;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
movl %eax, %edi
callq 0x6630
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x5705
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x56d3
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: buildMeasureFromASTEvents
static void
buildMeasureFromASTEvents(Measure *measure, char *astEvents, char *astTimingEvents)
    {
    int i;
    DoubleArray *eventDurations = parseMeasureEventDurations(astTimingEvents, (int)measure->beatsInMeasure);
    NoteInstance *ni;
    double currentDuration;
    
    for (i = 0; i < eventDurations->length; i++)
        {
        ni = newNoteInstance();
        /* ni->noteName == 0 is rest */
        ni->noteName = astEvents == 0 ? 0 : ((astEvents[i] == '-' || astEvents[i] == ' ') ? 0 : astEvents[i]);
        
        /* spaces ' ' hold the note length.  Loop through them, adding to the current duration. */
        currentDuration = eventDurations->values[i]; 
        for (; i < (eventDurations->length - 1) && (astEvents == 0 || astEvents[i+1] == ' '); i++)
            {
            currentDuration += eventDurations->values[i+1];
            }
        
        ni->duration = currentDuration;
        addNoteInstanceToMeasure(ni, measure);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x58e0
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x5892
callq 0x4e70
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5796
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x57d4
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0x57b8
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x57bf
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0x57ce
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x41(%rbp)
jge 0x5836
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x42(%rbp)
je 0x5830
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x583f
jmp 0x5869
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x57f4
movsd -0x38(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x5980
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x576f
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: parseMeasureEventDurations
static DoubleArray *
parseMeasureEventDurations(char *measureTimingEvents, int measureLengthInBeats)
    {
//printf("[parseMeasureEventDurations]\n");
    StringArray *timingEventsByQuarterNote;
    DoubleArray *retVal = 0;
    int i;
    
//printf("[%s]\n", measureTimingEvents);
    
    /* attempt to split into quarter notes */
    timingEventsByQuarterNote = splitTimingEvents(measureTimingEvents, charRange('1', measureLengthInBeats + '0'));
    
    /* parse event durations inside first half of beat */
    for (i = 0; i < timingEventsByQuarterNote->length; i++)
        {
//printf("[parseMeasureEventDurations] before concat %i: %s\n", i, timingEventsByQuarterNote->values[i]);
        retVal = concatDoubleArrays(retVal, parseQuarterNoteEventDurations(timingEventsByQuarterNote->values[i]));
//printf("[parseMeasureEventDurations] after concat %i: %s\n", i, timingEventsByQuarterNote->values[i]);
        }    
        
    return retVal;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
addl $0x30, %eax
movl $0x31, %edi
movsbl %al, %esi
callq 0x5b50
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x5a20
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x596c
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5d20
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5c10
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5929
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: charRange
static char *
charRange(char first, char last)
    {
//printf("[charRange] parameters, first: '%c', last: '%c'\n", first, last);
    char *range;
    char ch;
    if (first > last)
        {
        Fatal("in charRange: first '%c' greater than last '%c'\n", first, last);
        return 0;
        }
//printf("[charRange] range size: %i\n", last-first+2);
    range = (char *) New(sizeof(char) * (last-first+2)); /* range is inclusive AND must contain \0 */
    for (ch = first; ch <= last; ch++)
        {
//printf("[charRange] ch: '%c', index: %i\n", ch, ch-first);
        range[ch-first] = ch;
        }
//printf("[charRange] ch character 0, index: %i\n", last+1);
    range[last-first+1] = '\0';
//printf("[charRange] return value: '%s'\n", range);
    return range;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movsbl -0x9(%rbp), %eax
movsbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jle 0x5b90
movsbl -0x9(%rbp), %esi
movsbl -0xa(%rbp), %edx
leaq 0x28be(%rip), %rdi      # 0x843d
movb $0x0, %al
callq 0x63e0
movq $0x0, -0x8(%rbp)
jmp 0x5c01
movsbl -0xa(%rbp), %eax
movsbl -0x9(%rbp), %ecx
subl %ecx, %eax
addl $0x2, %eax
cltq
shlq $0x0, %rax
movl %eax, %edi
callq 0x6630
movq %rax, -0x18(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
movsbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jg 0x5be1
movb -0x19(%rbp), %dl
movq -0x18(%rbp), %rax
movsbl -0x19(%rbp), %ecx
movsbl -0x9(%rbp), %esi
subl %esi, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x5bb4
movq -0x18(%rbp), %rax
movsbl -0xa(%rbp), %ecx
movsbl -0x9(%rbp), %edx
subl %edx, %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5c49
cmpq $0x0, -0x18(%rbp)
jne 0x5c49
movq $0x0, -0x8(%rbp)
jmp 0x5d0d
cmpq $0x0, -0x10(%rbp)
jne 0x5c59
movl $0x0, -0x28(%rbp)
jmp 0x5c63
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5c73
movl $0x0, -0x2c(%rbp)
jmp 0x5c7d
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %edi
addl -0x2c(%rbp), %edi
callq 0x6060
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x5cc6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5c93
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x5d05
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0x28(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5ccd
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: parseQuarterNoteEventDurations
static DoubleArray *
parseQuarterNoteEventDurations(char *quarterNoteTimingEvents)
    {
//printf("[parseQuarterNoteEventDurations]\n");
    StringArray *timingEventsByEighthNote;
    DoubleArray *retVal = 0;
    
//printf("\t[%s]\n", quarterNoteTimingEvents);
    
    /* attempt to split into eighth notes */
    timingEventsByEighthNote = splitTimingEvents(quarterNoteTimingEvents, cons_str(quarterNoteTimingEvents[0], "&"));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
leaq 0x2727(%rip), %rsi      # 0x846e
movsbl (%rax), %edi
callq 0x60e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x5a20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5d70
movq -0x18(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0x5d87
movq -0x10(%rbp), %rdi
movsd 0x1324(%rip), %xmm0     # 0x70a0
callq 0x6170
movq %rax, -0x8(%rbp)
jmp 0x5dde
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x6230
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5c10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x6310
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x5c10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, %edi
callq 0x6630
movq %rax, -0x10(%rbp)
movslq -0x4(%rbp), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x6630
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x5e59
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5e33
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: split
static SplitString *
split(char *str, char ch)
    {
    SplitString *ss = (SplitString *) New(sizeof(SplitString));
    size_t memloc = (size_t)strchr(str, ch);
    size_t loc;
    
    if (memloc == 0)
        {
        ss->first = StringDup(str);
        ss->second = 0;
        }
    else
        {
        loc = memloc - (size_t)str;
        ss->first = substring(str, 0, loc);
        ss->second = substring(str, loc, strlen(str) - loc);
        }
    return ss;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x10, %edi
callq 0x6630
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x1070
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5ec9
movq -0x8(%rbp), %rdi
callq 0x65f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x5f2b
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x5fc0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
subq -0x28(%rbp), %rdx
callq 0x5fc0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: cons_strarr
static StringArray *
cons_strarr(char *car, StringArray *cdr)
    {
    int i;
    
//printf("[cons_strarr] 1\n");
//printf("[cons_strarr] cdr: {%zu}\n", (size_t)cdr);
    StringArray *newArray = newStringArray(cdr->length + 1);
//printf("[cons_strarr] 2\n");
    newArray->values[0] = car;
    
//printf("[cons_strarr] 3\n");
    for (i = 1; i < newArray->length; i++)
        {
//printf("[cons_strarr] 4 (iteration %i)\n", i);
        newArray->values[i] = cdr->values[i-1];
        }
//printf("[cons_strarr] 5\n");
    return newArray;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
addl $0x1, %edi
callq 0x5df0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x5fb2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5f78
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5fec
movq $0x0, -0x8(%rbp)
jmp 0x6052
movq -0x10(%rbp), %rdi
callq 0x1060
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x600f
cmpl $0x0, -0x24(%rbp)
je 0x600f
movslq -0x24(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x6021
leaq 0x11d9(%rip), %rdi      # 0x71ef
callq 0x65f0
movq %rax, -0x8(%rbp)
jmp 0x6052
movslq -0x24(%rbp), %rax
movq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jae 0x603d
movslq -0x24(%rbp), %rax
subq -0x18(%rbp), %rax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x10d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, %edi
callq 0x6630
movq %rax, -0x10(%rbp)
movslq -0x4(%rbp), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x6630
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x60c9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x60a3
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1060
addq $0x2, %rax
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rax
shlq $0x0, %rax
movl %eax, %edi
callq 0x6630
movq %rax, -0x20(%rbp)
movb -0x1(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x6153
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6125
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1060
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x6060
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x6212
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x2d(%rbp)
movsbl -0x2d(%rbp), %eax
cmpl $0x2e, %eax
je 0x61e9
cmpl $0x0, -0x2c(%rbp)
je 0x61e9
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x2298(%rip), %rdi      # 0x8470
movb $0x0, %al
callq 0x63e0
movq $0x0, -0x8(%rbp)
jmp 0x621a
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x61a0
movq -0x28(%rbp), %rax
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/pipde[P]deos-songlib/utils/processtab/tabchecker.c
// Function: parseFirstEighthNoteEventDurations
static DoubleArray *
parseFirstEighthNoteEventDurations(char *eighthNoteTimingEvents)
    {
//printf("[parseFirstEighthNoteEventDurations]\n");
    StringArray *timingEventsBySixteenthNote;
    DoubleArray *retVal = 0;
    
//printf("\t\t[%s]\n", eighthNoteTimingEvents);
    
    /* attempt to split into sixteenth notes */
    timingEventsBySixteenthNote = splitTimingEvents(eighthNoteTimingEvents, cons_str(eighthNoteTimingEvents[0], "e"));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
leaq 0xf81(%rip), %rsi       # 0x71d8
movsbl (%rax), %edi
callq 0x60e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x5a20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6280
movq -0x18(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0x6297
movq -0x10(%rbp), %rdi
movsd 0xe0c(%rip), %xmm0      # 0x7098
callq 0x6170
movq %rax, -0x8(%rbp)
jmp 0x62fe
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movsd 0xddf(%rip), %xmm0      # 0x7090
callq 0x6170
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5c10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
movsd 0xdaf(%rip), %xmm0      # 0x7090
callq 0x6170
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x5c10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)