LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/pistats.c
// Function: pistatsTravel
int pistatsTravel( char *strIn )
{
    char *mapName, *scenario, *mutator;
    int humanSide;

    mapName = rosterGetMapName();
    scenario = rosterGetScenario();
    mutator = rosterGetMutator();
    humanSide = rosterGetCoopSide();

    logPrintf( LOG_LEVEL_INFO, "pistats", "Change map to ::%s:: Scenario ::%s:: Mutator ::%s:: Human ::%d::", 
        mapName, scenario, mutator, humanSide );
    apiSay( "pistats: Test Map-Scenario %s::%s::%s::%d::", mapName, scenario, mutator, humanSide );

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x19410
movq %rax, -0x10(%rbp)
callq 0x19670
movq %rax, -0x18(%rbp)
callq 0x196c0
movq %rax, -0x20(%rbp)
callq 0x19450
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
movl -0x24(%rbp), %eax
movl $0x2, %edi
leaq 0x63d8(%rip), %rsi      # 0x28a52
leaq 0x5758(%rip), %rdx      # 0x27dd9
movl %eax, (%rsp)
movb $0x0, %al
callq 0x21bf0
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
leaq 0x64ae(%rip), %rdi      # 0x28b50
movb $0x0, %al
callq 0x178d0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/pistats.c
// Function: pistatsSessionLog
int pistatsSessionLog( char *strIn )
{
    char *sessionID;

    sessionID = rosterGetSessionID();

    logPrintf( LOG_LEVEL_INFO, "pistats", "Session ID ::%s::", sessionID );
    apiSay( "pistats: Session ID %s", sessionID );

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x19370
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movl $0x2, %edi
leaq 0x636d(%rip), %rsi      # 0x28a52
leaq 0x5759(%rip), %rdx      # 0x27e45
movb $0x0, %al
callq 0x21bf0
movq -0x10(%rbp), %rsi
leaq 0x647e(%rip), %rdi      # 0x28b7c
movb $0x0, %al
callq 0x178d0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/schroeder-lvb[P]sissm/src/pistats.c
// Function: pistatsObjectSynth
int pistatsObjectSynth( char *strIn )
{
    char *obj, *typ; 

    obj = rosterGetObjective();
    typ = rosterGetObjectiveType();

    logPrintf( LOG_LEVEL_INFO, "pistats", "Roster Objective is ::%s::, Type is ::%s::", obj, typ ); 
    apiSay( "pistats: Roster Objective is ::%s::, Type is ::%s::", obj, typ ); 

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x193c0
movq %rax, -0x10(%rbp)
callq 0x193d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x2, %edi
leaq 0x6310(%rip), %rsi      # 0x28a52
leaq 0x572c(%rip), %rdx      # 0x27e75
movb $0x0, %al
callq 0x21bf0
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x6434(%rip), %rdi      # 0x28b93
movb $0x0, %al
callq 0x178d0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zyearn[P]SmallC/lex.yy.c
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 101 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 100);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x2f88a(%rip), %rax     # 0x3e2f8
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x2694f(%rip), %rax     # 0x353d0
cmpw $0x0, (%rax,%rcx,2)
je 0xea9c
movl -0x4(%rbp), %eax
movl %eax, 0x2f873(%rip)     # 0x3e304
movq -0x10(%rbp), %rax
movq %rax, 0x2f86c(%rip)     # 0x3e308
jmp 0xea9e
movslq -0x4(%rbp), %rcx
leaq 0x26b57(%rip), %rax     # 0x35600
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x269e3(%rip), %rax     # 0x354a0
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0xeaf3
movslq -0x4(%rbp), %rcx
leaq 0x26bff(%rip), %rax     # 0x356d0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x65, -0x4(%rbp)
jl 0xeaf1
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x26cb5(%rip), %rax     # 0x357a0
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0xea9e
movslq -0x4(%rbp), %rcx
leaq 0x26b02(%rip), %rax     # 0x35600
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x26cce(%rip), %rax     # 0x357e0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x64, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0xeb35
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0xeb3b
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zyearn[P]SmallC/./treeNode.h
// Function: treeNode::treeNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
treeNode(string str, int n, int t=0)
    {
        childnum = n;
        type = t;
        data = str;

        child = new treeNode*[childnum];
        for(int i=0; i<childnum; i++)
            child[i] = NULL;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x3380
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, 0x20(%rdi)
movl -0x18(%rbp), %eax
movl %eax, 0x24(%rdi)
callq 0x3050
jmp 0xfdf9
movq -0x40(%rbp), %rax
movslq 0x20(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x48(%rbp)
jmp 0xfe22
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl $0x0, -0x28(%rbp)
movq -0x40(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0xfe77
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x28(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xfe35
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x34f8
jmp 0xfe7d
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zyearn[P]SmallC/./treeNode.h
// Function: treeNode::Clear(treeNode*)
void Clear(treeNode *t)
    {
        if(t == NULL) return ;
        int i;
        for(i=0; i<t->childnum; i++)
            Clear(t->child[i]);
        for(i=0; i<t->childnum; i++)
            delete t->child[i];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xffb4
jmp 0x1003c
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0xffeb
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xff90
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xffbb
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x1003c
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1002f
movq -0x28(%rbp), %rdi
callq 0x10390
movq -0x28(%rbp), %rdi
movl $0x30, %esi
callq 0x3280
jmp 0x10031
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xfff2
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zyearn[P]SmallC/codegen.cpp
// Function: genProgram(treeNode*)
void genProgram(treeNode* node)
{
//  freopen("t.s","w",stdout);
    cout << ".data" << endl;
    cout << "newline: .asciiz \"\\n\"" << endl;
    cout << ".text\n.globl main\n";
    genExtdefs(node->child[0], node->child[0]->type);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x28d7d(%rip), %rdi     # 0x3dfd0
leaq 0x20b70(%rip), %rsi     # 0x35dca
callq 0x3250
movq %rax, %rdi
movq 0x28d47(%rip), %rsi     # 0x3dfb0
callq 0x32b0
movq 0x28d5b(%rip), %rdi     # 0x3dfd0
leaq 0x20b54(%rip), %rsi     # 0x35dd0
callq 0x3250
movq %rax, %rdi
movq 0x28d25(%rip), %rsi     # 0x3dfb0
callq 0x32b0
movq 0x28d39(%rip), %rdi     # 0x3dfd0
leaq 0x20b48(%rip), %rsi     # 0x35de6
callq 0x3250
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movl 0x24(%rax), %esi
callq 0x152d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zyearn[P]SmallC/codegen.cpp
// Function: genExtdefs(treeNode*, int)
void genExtdefs(treeNode* node,int type)
{
    switch(type)
    {
        case 1:
            genExtdef(node->child[0], node->child[0]->type);
            genExtdefs(node->child[1], node->child[1]->type);
            break;
        case 2:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x152f6
jmp 0x152ec
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x15336
jmp 0x15338
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movl 0x24(%rax), %esi
callq 0x15340
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movl 0x24(%rax), %esi
callq 0x152d0
jmp 0x15338
jmp 0x15338
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zyearn[P]SmallC/codegen.cpp
// Function: genExtvars(treeNode*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void genExtvars(treeNode* node, int type, string scope)
{
    switch(type)
    {
        case 1:
        genDec(node->child[0], node->child[0]->type, "_G");
        break;
        case 2:
        genDec(node->child[0], node->child[0]->type, "_G");
        genExtvars(node->child[2], node->child[2]->type, "_G");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0xa0(%rbp)
subl $0x1, %eax
je 0x159ba
jmp 0x159a6
movl -0xa0(%rbp), %eax
subl $0x2, %eax
je 0x15a5e
jmp 0x15b4a
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0xac(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3460
movq -0xa8(%rbp), %rdx
leaq 0x1ff49(%rip), %rsi     # 0x3593c
leaq -0x38(%rbp), %rdi
callq 0xfd00
jmp 0x159fe
movl -0xac(%rbp), %esi
movq -0xb8(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x15cd0
jmp 0x15a16
leaq -0x38(%rbp), %rdi
callq 0x34f8
leaq -0x39(%rbp), %rdi
callq 0x32f0
jmp 0x15b4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x15a50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34f8
leaq -0x39(%rbp), %rdi
callq 0x32f0
jmp 0x15bb3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0xd0(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0xc4(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3460
movq -0xc0(%rbp), %rdx
leaq 0x1fea5(%rip), %rsi     # 0x3593c
leaq -0x70(%rbp), %rdi
callq 0xfd00
jmp 0x15aa2
movl -0xc4(%rbp), %esi
movq -0xd0(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x15cd0
jmp 0x15aba
leaq -0x70(%rbp), %rdi
callq 0x34f8
leaq -0x71(%rbp), %rdi
callq 0x32f0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0xe8(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0xdc(%rbp)
leaq -0x99(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x3460
movq -0xd8(%rbp), %rdx
leaq 0x1fe33(%rip), %rsi     # 0x3593c
leaq -0x98(%rbp), %rdi
callq 0xfd00
jmp 0x15b17
movl -0xdc(%rbp), %esi
movq -0xe8(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq 0x15980
jmp 0x15b32
leaq -0x98(%rbp), %rdi
callq 0x34f8
leaq -0x99(%rbp), %rdi
callq 0x32f0
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x15b76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x34f8
leaq -0x71(%rbp), %rdi
callq 0x32f0
jmp 0x15bb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x15ba7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x34f8
leaq -0x99(%rbp), %rdi
callq 0x32f0
movq -0x48(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zyearn[P]SmallC/codegen.cpp
// Function: genDefs(treeNode*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void genDefs(treeNode* node, int type, string scope)
{   
    //printf("has entered genDefs() ,type =%d \n", type);
    
    switch(type)
    {
        case 1:
    //  printf("ready to enter genDef()\n");
        genDef(node->child[0], node->child[0]->type, scope);
        genDefs(node->child[1], node->child[1]->type, scope);
        break;
        case 2:
        /*
        if(FT[scope] == 0)
        {
            FT[scope] = new map<string, int>();
        }*/
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x6c(%rbp)
subl $0x1, %eax
je 0x16b08
jmp 0x16af7
movl -0x6c(%rbp), %eax
subl $0x2, %eax
je 0x16bd9
jmp 0x16bdb
movq -0x78(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3150
movq -0x90(%rbp), %rdi
movl -0x84(%rbp), %esi
movq -0x80(%rbp), %rdx
callq 0x30310
jmp 0x16b4c
leaq -0x38(%rbp), %rdi
callq 0x34f8
movq -0x78(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa8(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0x9c(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3150
movq -0xa8(%rbp), %rdi
movl -0x9c(%rbp), %esi
movq -0x98(%rbp), %rdx
callq 0x16ad0
jmp 0x16ba0
leaq -0x68(%rbp), %rdi
callq 0x34f8
jmp 0x16bdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34f8
jmp 0x16be4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x34f8
jmp 0x16be4
jmp 0x16bdb
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zyearn[P]SmallC/codegen.cpp
// Function: genStmts(treeNode*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void genStmts(treeNode* node, int type, string scope, int labelN)
{
    switch(type)
    {
        case 1:
        genStmt(node->child[0], node->child[0]->type, scope, labelN);
        //
                genStmts(node->child[1], node->child[1]->type, scope, labelN);
        break;
        case 2:
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x74(%rbp)
subl $0x1, %eax
je 0x16c2b
jmp 0x16c1a
movl -0x74(%rbp), %eax
subl $0x2, %eax
je 0x16d08
jmp 0x16d0a
movq -0x80(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x98(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0x8c(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3150
movq -0x98(%rbp), %rdi
movl -0x8c(%rbp), %esi
movq -0x88(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x16d20
jmp 0x16c78
leaq -0x40(%rbp), %rdi
callq 0x34f8
movq -0x80(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0xb0(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0xa4(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3150
movq -0xb0(%rbp), %rdi
movl -0xa4(%rbp), %esi
movq -0xa0(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x16bf0
jmp 0x16ccf
leaq -0x70(%rbp), %rdi
callq 0x34f8
jmp 0x16d0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x34f8
jmp 0x16d13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x34f8
jmp 0x16d13
jmp 0x16d0a
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zyearn[P]SmallC/codegen.cpp
// Function: genDecs(treeNode*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void genDecs(treeNode* node, int type, string scope)
{
    //printf("has entered genDecs()\n");

    switch(type)
    {
        case 1:
        genDec(node->child[0],node->child[0]->type, scope);
        genDecs(node->child[2],node->child[2]->type, scope);
        break;
        case 2:
        genDec(node->child[0],node->child[0]->type, scope);
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdx, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8c(%rbp)
subl $0x1, %eax
je 0x303d1
jmp 0x303bd
movl -0x8c(%rbp), %eax
subl $0x2, %eax
je 0x304b7
jmp 0x3052f
movq -0x98(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0xa4(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3150
movq -0xb0(%rbp), %rdi
movl -0xa4(%rbp), %esi
movq -0xa0(%rbp), %rdx
callq 0x15cd0
jmp 0x3041e
leaq -0x38(%rbp), %rdi
callq 0x34f8
movq -0x98(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0xc8(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0xbc(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3150
movq -0xc8(%rbp), %rdi
movl -0xbc(%rbp), %esi
movq -0xb8(%rbp), %rdx
callq 0x30390
jmp 0x30475
leaq -0x68(%rbp), %rdi
callq 0x34f8
jmp 0x3052f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34f8
jmp 0x30538
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x34f8
jmp 0x30538
movq -0x98(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0xd4(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3150
movq -0xe0(%rbp), %rdi
movl -0xd4(%rbp), %esi
movq -0xd0(%rbp), %rdx
callq 0x15cd0
jmp 0x30507
leaq -0x88(%rbp), %rdi
callq 0x34f8
jmp 0x3052f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x34f8
jmp 0x30538
addq $0xe0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zyearn[P]SmallC/codegen.cpp
// Function: genInit(treeNode*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void genInit(treeNode* node, int type, string scope)
{
    switch(type)
    {
        case 1:
            genExp(node->child[0], node->child[0]->type, scope);
            break;
        case 2:// struct
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x48(%rbp)
subl $0x1, %eax
je 0x3057e
jmp 0x30574
movl -0x48(%rbp), %eax
subl $0x2, %eax
je 0x305da
jmp 0x305dc
movq -0x50(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3150
movq -0x68(%rbp), %rdi
movl -0x5c(%rbp), %esi
movq -0x58(%rbp), %rdx
xorl %ecx, %ecx
callq 0x18f60
jmp 0x305b8
leaq -0x38(%rbp), %rdi
callq 0x34f8
jmp 0x305dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34f8
jmp 0x305e2
jmp 0x305dc
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3450
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/alarm_thread.c
// Function: alarm_thread
void *alarm_thread(struct alarm *a)
{
	int status = pthread_detach(pthread_self());
	if (status != 0)
	{
		fprintf(stderr, "pthread_detach: %s\n", strerror(status));
		exit(EXIT_FAILURE);
	}

	sleep(a->seconds);
	printf("(%d) %s\n", a->seconds, a->message);
	free(a);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x10d0
movq %rax, %rdi
callq 0x10a0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x1267
movq 0x2dbf(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x10f0
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0xdae(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x10e0
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x1100
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rdx
addq $0x4, %rdx
leaq 0xd91(%rip), %rdi       # 0x2018
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/alarm_thread.c
// Function: main
int main(void)
{
	int status;
	char line[128];
	struct alarm *a;
	pthread_t thread;

	while (printf("Alarm> ") && fgets(line, sizeof(line), stdin))
	{
		if (strlen(line) <= 1)
			continue;

		if (!(a = malloc(sizeof(*a))))
		{
			fputs("Failed to allocate alarm\n", stderr);
			return EXIT_FAILURE;
		}
		if (sscanf(line, "%d %64[^\n]", &a->seconds, a->message) < 2)
		{
			fputs("Bad command\n", stderr);
			free(a);
		}
		else
		{
			status = pthread_create(&thread, NULL, (void *(*)(void*))alarm_thread, a);
			if (status != 0)
			{
				fprintf(stderr, "pthread_create: %s\n", strerror(status));
				return EXIT_FAILURE;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xd68(%rip), %rdi       # 0x2021
movb $0x0, %al
callq 0x1050
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xa1(%rbp)
je 0x12f7
leaq -0x90(%rbp), %rdi
movq 0x2cfb(%rip), %rax      # 0x3fd8
movq (%rax), %rdx
movl $0x80, %esi
callq 0x1070
cmpq $0x0, %rax
setne %al
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x1306
jmp 0x140b
leaq -0x90(%rbp), %rdi
callq 0x1040
cmpq $0x1, %rax
ja 0x131a
jmp 0x12b2
movl $0x44, %edi
callq 0x1090
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
jne 0x1353
movq 0x2cc0(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xce7(%rip), %rdi       # 0x2029
callq 0x1060
movl $0x1, -0x4(%rbp)
jmp 0x140b
leaq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rdx
movq -0x98(%rbp), %rcx
addq $0x4, %rcx
leaq 0xcd0(%rip), %rsi       # 0x2043
movb $0x0, %al
callq 0x10b0
cmpl $0x2, %eax
jge 0x13a3
movq 0x2c72(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xcbe(%rip), %rdi       # 0x204e
callq 0x1060
movq -0x98(%rbp), %rdi
callq 0x1030
jmp 0x1406
movq -0x98(%rbp), %rcx
leaq -0xa0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x1ac(%rip), %rdx      # 0x1210
callq 0x10c0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1404
movq 0x2c27(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
movl -0x8(%rbp), %edi
callq 0x10f0
movq -0xb0(%rbp), %rdi
movq %rax, %rdx
leaq 0xc67(%rip), %rsi       # 0x205b
movb $0x0, %al
callq 0x1080
movl $0x1, -0x4(%rbp)
jmp 0x140b
jmp 0x1406
jmp 0x12b2
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hkshenSmart[P]ONVIF-discovery_cs/soapServer.c
// Function: soap_serve
int SOAP_FMAC6 soap_serve(struct soap *soap)
{
#ifndef WITH_FASTCGI
	unsigned int k = soap->max_keep_alive;
#endif
	do
	{
#ifndef WITH_FASTCGI
		if (soap->max_keep_alive > 0 && !--k)
			soap->keep_alive = 0;
#endif
		if (soap_begin_serve(soap))
		{	if (soap->error >= SOAP_STOP)
				continue;
			return soap->error;
		}
		if (soap_serve_request(soap) || (soap->fserveloop && soap->fserveloop(soap)))
		{
#ifdef WITH_FASTCGI
			soap_send_fault(soap);
#else
			return soap_send_fault(soap);
#endif
		}

#ifdef WITH_FASTCGI
		soap_destroy(soap);
		soap_end(soap);
	} while (1);
#else
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x1f23c(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1f23c(%rax)
jbe 0x16541
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x16541
movq -0x10(%rbp), %rax
movw $0x0, 0x1f22c(%rax)
movq -0x10(%rbp), %rdi
callq 0x334a0
cmpl $0x0, %eax
je 0x16570
movq -0x10(%rbp), %rax
cmpl $0x3e8, 0x1f274(%rax)   # imm = 0x3E8
jl 0x16561
jmp 0x165b2
movq -0x10(%rbp), %rax
movl 0x1f274(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x165cb
movq -0x10(%rbp), %rdi
callq 0x165e0
cmpl $0x0, %eax
jne 0x165a2
movq -0x10(%rbp), %rax
cmpq $0x0, 0xc050(%rax)
je 0x165b0
movq -0x10(%rbp), %rax
movq 0xc050(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x165b0
movq -0x10(%rbp), %rdi
callq 0x34060
movl %eax, -0x4(%rbp)
jmp 0x165cb
jmp 0x165b2
movq -0x10(%rbp), %rax
cmpw $0x0, 0x1f22c(%rax)
jne 0x16519
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hkshenSmart[P]ONVIF-discovery_cs/soapServer.c
// Function: soap_serve_request
SOAP_FMAC6 soap_serve_request(struct soap *soap)
{
	soap_peek_element(soap);
	if (!soap_match_tag(soap, soap->tag, "d:Probe"))
		return soap_serve___dndl__Probe(soap);
	if (!soap_match_tag(soap, soap->tag, "d:Hello"))
		return soap_serve___dnrd__Hello(soap);
	if (!soap_match_tag(soap, soap->tag, "d:Bye"))
		return soap_serve___dnrd__Bye(soap);
	return soap->error = SOAP_NO_METHOD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a110
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1c998, %rsi          # imm = 0x1C998
leaq 0x2232b(%rip), %rdx     # 0x38936
callq 0x1d690
cmpl $0x0, %eax
jne 0x16623
movq -0x10(%rbp), %rdi
callq 0x166a0
movl %eax, -0x4(%rbp)
jmp 0x16694
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1c998, %rsi          # imm = 0x1C998
leaq 0x222f5(%rip), %rdx     # 0x3892e
callq 0x1d690
cmpl $0x0, %eax
jne 0x16651
movq -0x10(%rbp), %rdi
callq 0x168f0
movl %eax, -0x4(%rbp)
jmp 0x16694
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1c998, %rsi          # imm = 0x1C998
leaq 0x222bd(%rip), %rdx     # 0x38924
callq 0x1d690
cmpl $0x0, %eax
jne 0x1667f
movq -0x10(%rbp), %rdi
callq 0x16b40
movl %eax, -0x4(%rbp)
jmp 0x16694
movq -0x10(%rbp), %rax
movl $0xd, 0x1f274(%rax)
movl $0xd, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/amo-fetch.c
// Function: main
int
main()
{
    int me;

    shmem_init();
    me = shmem_my_pe();

    if (me == 0) {
        const int fetched = shmem_int_atomic_fetch(&dst, 1);

        printf("%d: dst = %d, fetched value = %d\n", me, dst, fetched);
    }

    shmem_barrier_all();

    printf("%d: dst = %d\n", me, dst);

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
callq 0x1080
callq 0x1060
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jne 0x11e2
leaq 0x2ea0(%rip), %rdi      # 0x4058
movl $0x1, %esi
callq 0x1040
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %esi
movl 0x2e88(%rip), %edx      # 0x4058
movl 0xc(%rsp), %ecx
leaq 0xe29(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
callq 0x1070
movl 0x10(%rsp), %esi
movl 0x2e67(%rip), %edx      # 0x4058
leaq 0xe2e(%rip), %rdi       # 0x2026
movb $0x0, %al
callq 0x1030
callq 0x1050
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/ecc/hamming.c
// Function: hamming_generate
void hamming_generate(const uint8_t *chunk, size_t len, uint8_t *ecc)
{
	hamming_ecc_t p = parity_scan(chunk, len);

	ecc[0] = p;
	p >>= 8;
	ecc[1] = p;
	p >>= 8;
	ecc[2] = p;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1200
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, (%rax)
movl 0xc(%rsp), %eax
shrl $0x8, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, 0x1(%rax)
movl 0xc(%rsp), %eax
shrl $0x8, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, 0x2(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/ecc/hamming.c
// Function: hamming_syndrome
hamming_ecc_t hamming_syndrome(const uint8_t *chunk, size_t len,
			       const uint8_t *ecc)
{
	const hamming_ecc_t p = parity_scan(chunk, len);
	hamming_ecc_t q = 0;

	q |= ecc[2];
	q <<= 8;
	q |= ecc[1];
	q <<= 8;
	q |= ecc[0];

	return p ^ q;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1200
movl %eax, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl 0x2(%rax), %eax
orl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
shll $0x8, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl 0x1(%rax), %eax
orl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
shll $0x8, %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
orl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
xorl 0x8(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/ecc/hamming.c
// Function: hamming_repair
int hamming_repair(uint8_t *chunk, size_t len, hamming_ecc_t syndrome)
{
	int pos = 0;
	int pos_bit = 1;
	int i;

	/* There might be no error */
	if (!syndrome)
		return 0;

	/* The single-bit error might be in the ECC data itself. */
	if (!(syndrome & (syndrome - 1)))
		return 0;

	/* Otherwise, go on the assumption that there's a single-bit
	 * error in the chunk. If this is true, then exactly one out of
	 * every complementary pair of syndrome bits should be set.
	 */
	for (i = 0; i < HAMMING_LOG2_CHUNK_BITS; i++) {
		const int s = syndrome & 3;

		if (s == 1)
			pos |= pos_bit;
		else if (s != 2)
			return -1;

		syndrome >>= 2;
		pos_bit <<= 1;
	}

	/* Flip the bit back */
	if ((pos >> 3) < len)
		chunk[pos >> 3] ^= 1 << (pos & 7);

	return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movl $0x0, -0x20(%rsp)
movl $0x1, -0x24(%rsp)
cmpl $0x0, -0x1c(%rsp)
jne 0x14d2
movl $0x0, -0x4(%rsp)
jmp 0x1593
movl -0x1c(%rsp), %eax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x14f1
movl $0x0, -0x4(%rsp)
jmp 0x1593
movl $0x0, -0x28(%rsp)
cmpl $0xc, -0x28(%rsp)
jge 0x1555
movl -0x1c(%rsp), %eax
andl $0x3, %eax
movl %eax, -0x2c(%rsp)
cmpl $0x1, -0x2c(%rsp)
jne 0x1520
movl -0x24(%rsp), %eax
orl -0x20(%rsp), %eax
movl %eax, -0x20(%rsp)
jmp 0x1533
cmpl $0x2, -0x2c(%rsp)
je 0x1531
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1593
jmp 0x1533
movl -0x1c(%rsp), %eax
shrl $0x2, %eax
movl %eax, -0x1c(%rsp)
movl -0x24(%rsp), %eax
shll %eax
movl %eax, -0x24(%rsp)
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x14f9
movl -0x20(%rsp), %eax
sarl $0x3, %eax
cltq
cmpq -0x18(%rsp), %rax
jae 0x158b
movl -0x20(%rsp), %ecx
andl $0x7, %ecx
movl $0x1, %esi
shll %cl, %esi
movq -0x10(%rsp), %rax
movl -0x20(%rsp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/hamming.c
// Function: test_code
static void test_code(void)
{
	uint8_t block[TEST_CHUNK_SIZE];
	int i;

	memset(block, 0xff, sizeof(block));
	test_properties(block);

	for (i = 0; i < 10; i++)
		test_random_block();
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
leaq 0x10(%rsp), %rdi
movl $0xff, %esi
movl $0x203, %edx            # imm = 0x203
callq 0x1050
leaq 0x10(%rsp), %rdi
callq 0x1610
movl $0x0, 0xc(%rsp)
cmpl $0xa, 0xc(%rsp)
jge 0x1606
callq 0x1690
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x15ed
addq $0x218, %rsp            # imm = 0x218
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/hamming.c
// Function: test_properties
static void test_properties(const uint8_t *block)
{
	hamming_ecc_t e;
	int i;

	e = hamming_syndrome(block, HAMMING_CHUNK_SIZE,
			     block + HAMMING_CHUNK_SIZE);
	assert(!e);

	for (i = 0; i < 20; i++)
		flip_test(block);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rdx
addq $0x200, %rdx            # imm = 0x200
movl $0x200, %esi            # imm = 0x200
callq 0x1410
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x1641
jmp 0x1660
leaq 0xac8(%rip), %rdi       # 0x2110
leaq 0xac4(%rip), %rsi       # 0x2113
movl $0x3c, %edx
leaq 0xac8(%rip), %rcx       # 0x2123
callq 0x1040
movl $0x0, 0x8(%rsp)
cmpl $0x14, 0x8(%rsp)
jge 0x1686
movq 0x10(%rsp), %rdi
callq 0x1700
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1668
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/hamming.c
// Function: test_random_block
static void test_random_block(void)
{
	uint8_t block[TEST_CHUNK_SIZE];
	int i;

	for (i = 0; i < HAMMING_CHUNK_SIZE; i++)
		block[i] = random();

	hamming_generate(block, HAMMING_CHUNK_SIZE,
			 block + HAMMING_CHUNK_SIZE);
	test_properties(block);
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movl $0x0, 0xc(%rsp)
cmpl $0x200, 0xc(%rsp)       # imm = 0x200
jge 0x16c6
callq 0x1080
movb %al, %cl
movslq 0xc(%rsp), %rax
movb %cl, 0x10(%rsp,%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x169f
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rdx
addq $0x200, %rdx            # imm = 0x200
movl $0x200, %esi            # imm = 0x200
callq 0x1190
leaq 0x10(%rsp), %rdi
callq 0x1610
addq $0x218, %rsp            # imm = 0x218
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/hamming.c
// Function: flip_test
static void flip_test(const uint8_t *good)
{
	uint8_t bad[TEST_CHUNK_SIZE];
	int i;
	hamming_ecc_t e;

	memcpy(bad, good, sizeof(bad));
	flip_one_bit(bad, TEST_CHUNK_SIZE);

	e = hamming_syndrome(bad, HAMMING_CHUNK_SIZE,
			     bad + HAMMING_CHUNK_SIZE);
	assert(e);
	hamming_repair(bad, HAMMING_CHUNK_SIZE, e);

	i = memcmp(good, bad, HAMMING_CHUNK_SIZE);
	assert(!i);
}

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x220(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x220(%rsp), %rsi
movl $0x203, %edx            # imm = 0x203
callq 0x1070
leaq 0x10(%rsp), %rdi
movl $0x203, %esi            # imm = 0x203
callq 0x17e0
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rdx
addq $0x200, %rdx            # imm = 0x200
movl $0x200, %esi            # imm = 0x200
callq 0x1410
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x175d
jmp 0x177c
leaq 0x9ad(%rip), %rdi       # 0x2111
leaq 0x9a8(%rip), %rsi       # 0x2113
movl $0x2e, %edx
leaq 0x9d2(%rip), %rcx       # 0x2149
callq 0x1040
leaq 0x10(%rsp), %rdi
movl 0x8(%rsp), %edx
movl $0x200, %esi            # imm = 0x200
callq 0x14a0
movq 0x220(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x1060
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x17b3
jmp 0x17d2
leaq 0x9af(%rip), %rdi       # 0x2169
leaq 0x952(%rip), %rsi       # 0x2113
movl $0x32, %edx
leaq 0x97c(%rip), %rcx       # 0x2149
callq 0x1040
addq $0x228, %rsp            # imm = 0x228
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wc2.c
// Function: build_urow
void build_urow(unsigned ubase, unsigned id, unsigned next)
{
    size_t i;
    unsigned default_state;

    default_state = table[ubase + ILLEGAL][0];

    if (next == 0)
        next = default_state;
    else
        next = ubase + next;

    memcpy(table[ubase + id], table[ubase + ILLEGAL], 256);

    for (i=0x80; i<0xC0; i++) {
        table[ubase + id][i] = next;
    }
    for (i=0xC0; i<0x100; i++) {
        table[ubase + id][i] = ubase + ILLEGAL;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %eax
addl $0x1e, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x3b4e(%rip), %rax      # 0x50f0
shlq $0x8, %rcx
addq %rcx, %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x15bd
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x15c6
movl -0x4(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
movl %eax, %eax
leaq 0x3b1b(%rip), %rdi      # 0x50f0
shlq $0x8, %rax
addq %rax, %rdi
movl -0x4(%rbp), %eax
addl $0x1e, %eax
movl %eax, %eax
leaq 0x3b05(%rip), %rsi      # 0x50f0
shlq $0x8, %rax
addq %rax, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x1110
movq $0x80, -0x18(%rbp)
cmpq $0xc0, -0x18(%rbp)
jae 0x1640
movl -0xc(%rbp), %eax
movb %al, %dl
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x3acc(%rip), %rax      # 0x50f0
shlq $0x8, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1604
movq $0xc0, -0x18(%rbp)
cmpq $0x100, -0x18(%rbp)     # imm = 0x100
jae 0x1687
movl -0x4(%rbp), %eax
addl $0x1e, %eax
movb %al, %dl
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x3a85(%rip), %rax      # 0x50f0
shlq $0x8, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1648
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wc2.c
// Function: compile_pointers
static void
compile_pointers(void)
{
    size_t i;
    size_t j;

    for (i=0; i<STATE_MAX; i++) {
        for (j=0; j<256; j++) {
            table_p[i][j] = (char*)table_p + table[i][j]*256*sizeof(void*);
            assert(PSTATE(table_p[i][j]) == table[i][j]);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
cmpq $0x42, -0x8(%rbp)
jae 0x2626
movq $0x0, -0x10(%rbp)
cmpq $0x100, -0x10(%rbp)     # imm = 0x100
jae 0x2613
movq -0x8(%rbp), %rcx
leaq 0x2b94(%rip), %rax      # 0x50f0
shlq $0x8, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
cltq
shlq $0x3, %rax
leaq 0x12b75(%rip), %rdx     # 0x150f0
addq %rax, %rdx
movq -0x8(%rbp), %rcx
leaq 0x12b67(%rip), %rax     # 0x150f0
shlq $0xb, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rcx
leaq 0x12b4d(%rip), %rax     # 0x150f0
shlq $0xb, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
leaq 0x12b37(%rip), %rcx     # 0x150f0
subq %rcx, %rax
shrq $0xb, %rax
movq -0x8(%rbp), %rdx
leaq 0x2b25(%rip), %rcx      # 0x50f0
shlq $0x8, %rdx
addq %rdx, %rcx
movq -0x10(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpq %rcx, %rax
jne 0x25e1
jmp 0x2600
leaq 0xcd3(%rip), %rdi       # 0x32bb
leaq 0xcf1(%rip), %rsi       # 0x32e0
movl $0x15b, %edx            # imm = 0x15B
leaq 0xceb(%rip), %rcx       # 0x32e6
callq 0x10b0
jmp 0x2602
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2543
jmp 0x2615
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2530
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wc2.c
// Function: parse_file
static struct results
parse_file(FILE *fp, const struct config *cfg)
{
    enum {BUFSIZE=65536};
    struct results results = {0, 0, 0, 0};
    unsigned state = 0; /* state held between chunks */
    unsigned char *buf;

    buf = malloc(BUFSIZE);
    if (buf == NULL)
        abort();

    /* Process a 64k chunk at a time */
    for (;;) {
        size_t count;
        struct results x;

        /* Read the next chunk of data from the file */
        count = fread(buf, 1, BUFSIZE, fp);
        if (count <= 0)
            break;

        /* Do the word-count algorithm */
        if (cfg->is_pointer_arithmetic > 1)
            x = parse_chunk_pp(buf, count, &state);
        else if (cfg->is_pointer_arithmetic)
            x = parse_chunk_p(buf, count, &state);
        else
            x = parse_chunk(buf, count, &state);

        /* Sum the results */
        results.line_count += x.line_count;
        results.word_count += x.word_count;
        results.byte_count += x.byte_count;
        results.char_count += x.char_count;
    }

    free(buf);
    return results;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorl %esi, %esi
movl $0x20, %edx
callq 0x10c0
movl $0x0, -0x14(%rbp)
movl $0x10000, %edi          # imm = 0x10000
callq 0x1120
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2681
callq 0x1040
jmp 0x2683
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
ja 0x26aa
jmp 0x27b5
movq -0x10(%rbp), %rax
cmpl $0x1, 0x24(%rax)
jle 0x26ee
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x68(%rbp), %rdi
leaq -0x14(%rbp), %rcx
callq 0x2af0
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x277b
movq -0x10(%rbp), %rax
cmpl $0x0, 0x24(%rax)
je 0x2735
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x88(%rbp), %rdi
leaq -0x14(%rbp), %rcx
callq 0x2c50
movq -0x88(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x2779
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0xa8(%rbp), %rdi
leaq -0x14(%rbp), %rcx
callq 0x2d70
movq -0xa8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x277b
movq -0xb8(%rbp), %rax
movq -0x48(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rcx
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0x2683
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0xb0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wc2.c
// Function: print_results
static void
print_results(const char *filename, struct results *results, struct config *cfg)
{
    int needs_space = 0; /* space needed between output */
    unsigned width = cfg->column_width;

    /* -l */
    if (cfg->is_counting_lines)
        printf("%s%*lu", needs_space++?" ":"", width, results->line_count);

    /* -w */
    if (cfg->is_counting_words)
        printf("%s%*lu", needs_space++?" ":"", width, results->word_count);

    /* -c */
    if (cfg->is_counting_bytes)
        printf("%s%*lu", needs_space++?" ":"", width, results->byte_count);

    /* -m */
    if (cfg->is_counting_chars)
        printf("%s%*lu", needs_space++?" ":"", width, results->char_count);

    /* NULL if <stdin>, "total" for the last line showing totals, otherwise,
     * the name of the file that was processed */
    if (filename)
        printf("%s%s", needs_space++?" ":"", filename);
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x2837
movl -0x1c(%rbp), %ecx
movl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq 0x911(%rip), %rsi       # 0x3122
leaq 0xaf1(%rip), %rax       # 0x3309
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
leaq 0xad2(%rip), %rdi       # 0x3302
movb $0x0, %al
callq 0x10a0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x287a
movl -0x1c(%rbp), %ecx
movl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq 0x8cf(%rip), %rsi       # 0x3122
leaq 0xaaf(%rip), %rax       # 0x3309
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0xa8f(%rip), %rdi       # 0x3302
movb $0x0, %al
callq 0x10a0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x28bd
movl -0x1c(%rbp), %ecx
movl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq 0x88c(%rip), %rsi       # 0x3122
leaq 0xa6c(%rip), %rax       # 0x3309
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xa4c(%rip), %rdi       # 0x3302
movb $0x0, %al
callq 0x10a0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x2900
movl -0x1c(%rbp), %ecx
movl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq 0x849(%rip), %rsi       # 0x3122
leaq 0xa29(%rip), %rax       # 0x3309
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0xa09(%rip), %rdi       # 0x3302
movb $0x0, %al
callq 0x10a0
cmpq $0x0, -0x8(%rbp)
je 0x2939
movl -0x1c(%rbp), %ecx
movl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq 0x809(%rip), %rsi       # 0x3122
leaq 0x9e9(%rip), %rax       # 0x3309
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movq -0x8(%rbp), %rdx
leaq 0x9d9(%rip), %rdi       # 0x330b
movb $0x0, %al
callq 0x10a0
leaq 0x7e1(%rip), %rdi       # 0x3121
movb $0x0, %al
callq 0x10a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/robertdavidgraham[P]wc2/wc2.c
// Function: print_help
static void
print_help(void)
{
    printf("wc -- word, line, and byte or character count\n");
    printf("use:\n wc [-c|-m][-lw][file...]\n");
    printf("where:\n");
    printf(" -c\tPrint the number of bytes in each input file.\n");
    printf(" -l\tPrint the number of newlines in each input file.\n");
    printf(" -m\tPrint number of multibyte characters in each input file.\n");
    printf(" -w\tPrint the number of words in each input file.\n");
    printf("If no files specified, reads from stdin.\n");
    printf("If no options specified, -lwc will be used.\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7d8(%rip), %rdi       # 0x3133
movb $0x0, %al
callq 0x10a0
leaq 0x7f9(%rip), %rdi       # 0x3162
movb $0x0, %al
callq 0x10a0
leaq 0x80b(%rip), %rdi       # 0x3182
movb $0x0, %al
callq 0x10a0
leaq 0x805(%rip), %rdi       # 0x318a
movb $0x0, %al
callq 0x10a0
leaq 0x82a(%rip), %rdi       # 0x31bd
movb $0x0, %al
callq 0x10a0
leaq 0x852(%rip), %rdi       # 0x31f3
movb $0x0, %al
callq 0x10a0
leaq 0x882(%rip), %rdi       # 0x3231
movb $0x0, %al
callq 0x10a0
leaq 0x8a7(%rip), %rdi       # 0x3264
movb $0x0, %al
callq 0x10a0
leaq 0x8c3(%rip), %rdi       # 0x328e
movb $0x0, %al
callq 0x10a0
popq %rbp
retq
nopw %cs:(%rax,%rax)