LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dsesami[P]superscalar-processor-model/main.cc
// Function: robstatus()
void robstatus() {
    cout << "ROB -------------------" << endl;
    for(u_int i=0; i < ROB.size(); i++) {
        cout << i << ": " << "val " << ROB.at(i).valid << " ready "
             << ROB.at(i).ready;
        if(head == i) cout << " HEAD ";
        if(tail == i) cout << " TAIL ";
        cout << endl;
    }
        cout << "the address of this is..." << ROB.at(head).address << endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0xdee9(%rip), %rdi      # 0x10fd8
leaq 0x814c(%rip), %rsi      # 0xb242
callq 0x2190
movq %rax, %rdi
movq 0xdec3(%rip), %rsi      # 0x10fc8
callq 0x21c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x10(%rbp)
leaq 0xe2c9(%rip), %rdi      # 0x113e8
callq 0x37d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0x3218
movl -0x4(%rbp), %esi
movq 0xde9a(%rip), %rdi      # 0x10fd8
callq 0x2210
movq %rax, %rdi
leaq 0x8251(%rip), %rsi      # 0xb39e
callq 0x2190
movq %rax, %rdi
leaq 0x80fe(%rip), %rsi      # 0xb25a
callq 0x2190
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %esi
leaq 0xe277(%rip), %rdi      # 0x113e8
callq 0x3790
movq -0x20(%rbp), %rdi
movb (%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22f0
movq %rax, %rdi
leaq 0x80cf(%rip), %rsi      # 0xb25f
callq 0x2190
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %esi
leaq 0xe243(%rip), %rdi      # 0x113e8
callq 0x3790
movq -0x18(%rbp), %rdi
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22f0
movl 0xdfdf(%rip), %eax      # 0x111a0
cmpl -0x4(%rbp), %eax
jne 0x31d9
movq 0xde0b(%rip), %rdi      # 0x10fd8
leaq 0x8093(%rip), %rsi      # 0xb267
callq 0x2190
movl 0xdfc5(%rip), %eax      # 0x111a4
cmpl -0x4(%rbp), %eax
jne 0x31f7
movq 0xdded(%rip), %rdi      # 0x10fd8
leaq 0x807c(%rip), %rsi      # 0xb26e
callq 0x2190
movq 0xddda(%rip), %rdi      # 0x10fd8
movq 0xddc3(%rip), %rsi      # 0x10fc8
callq 0x21c0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3111
movq 0xddb9(%rip), %rdi      # 0x10fd8
leaq 0x804f(%rip), %rsi      # 0xb275
callq 0x2190
movq %rax, -0x28(%rbp)
movl 0xdf6b(%rip), %eax      # 0x111a0
movl %eax, %esi
leaq 0xe1aa(%rip), %rdi      # 0x113e8
callq 0x3790
movq -0x28(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0x2050
movq %rax, %rdi
movq 0xdd6e(%rip), %rsi      # 0x10fc8
callq 0x21c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: dsesami[P]superscalar-processor-model/decode.cc
// Function: decode()
void decode(){
    for(deque<bundle>::iterator j=DE_register.begin(); j!=DE_register.end(); j++) {
                // set first cycle and duration of this instruction.
        if(DE_register.size() && (j->decode_first == -1)) {
            j->decode_first = cycles;
        }
    }
    for(u_int i=0; i<WIDTH; i++) {



        // If the rename register is full, do nothing.
        if(RN_register.size() == WIDTH) {
            return;
        }
        // Otherwise go ahead and move a bundle to the rename register.
        else if(DE_register.size()) {
            DE_register.front().decode_time = cycles - DE_register.front().decode_first+1;
            RN_register.push_back(DE_register.front());
            DE_register.pop_front();
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq -0x20(%rbp), %rdi
leaq 0xa23d(%rip), %rsi      # 0x11450
callq 0x5050
leaq -0x40(%rbp), %rdi
leaq 0xa22d(%rip), %rsi      # 0x11450
callq 0x5080
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7350
testb $0x1, %al
jne 0x723b
jmp 0x728a
leaq 0xa20e(%rip), %rdi      # 0x11450
callq 0x3700
cmpq $0x0, %rax
je 0x7277
leaq -0x20(%rbp), %rdi
callq 0x7380
cmpl $-0x1, 0x2c(%rax)
jne 0x7277
leaq 0x9f71(%rip), %rax      # 0x111d4
movl (%rax), %eax
movl %eax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7380
movl -0x68(%rbp), %ecx
movl %ecx, 0x2c(%rax)
jmp 0x7279
leaq -0x60(%rbp), %rdi
leaq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x73a0
jmp 0x7218
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
leaq 0x9f29(%rip), %rcx      # 0x111c4
cmpl (%rcx), %eax
jae 0x7346
leaq 0xa1f6(%rip), %rdi      # 0x114a0
callq 0x3700
leaq 0x9f0e(%rip), %rcx      # 0x111c4
movl (%rcx), %ecx
cmpq %rcx, %rax
jne 0x72c2
jmp 0x7348
leaq 0xa187(%rip), %rdi      # 0x11450
callq 0x3700
cmpq $0x0, %rax
je 0x7334
leaq 0x9ef9(%rip), %rax      # 0x111d4
movl (%rax), %eax
movl %eax, -0x70(%rbp)
leaq 0xa169(%rip), %rdi      # 0x11450
callq 0x73e0
movq %rax, %rcx
movl -0x70(%rbp), %eax
subl 0x2c(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
leaq 0xa14e(%rip), %rdi      # 0x11450
callq 0x73e0
movl -0x6c(%rbp), %ecx
movl %ecx, 0x30(%rax)
leaq 0xa13c(%rip), %rdi      # 0x11450
callq 0x73e0
movq %rax, %rsi
leaq 0xa17d(%rip), %rdi      # 0x114a0
callq 0x6960
leaq 0xa121(%rip), %rdi      # 0x11450
callq 0x7410
jmp 0x7336
jmp 0x7338
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x7291
jmp 0x7348
addq $0x70, %rsp
popq %rbp
retq
nop
// File: dsesami[P]superscalar-processor-model/rename.cc
// Function: isrobfull()
bool isrobfull() {
    u_int empty_slots=ROBSIZE;
    for(u_int i=0; i<ROB.size(); i++) {
        if(ROB.at(i).valid) empty_slots--;
    }
    return (empty_slots < WIDTH) ? true : false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x97cd(%rip), %rax      # 0x111bc
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
leaq 0x99df(%rip), %rdi      # 0x113e8
callq 0x37d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0x7a46
movl -0x8(%rbp), %eax
movl %eax, %esi
leaq 0x99c2(%rip), %rdi      # 0x113e8
callq 0x3790
testb $0x1, (%rax)
je 0x7a39
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7a3b
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x79fb
movl -0x4(%rbp), %ecx
leaq 0x9774(%rip), %rax      # 0x111c4
movl (%rax), %edx
xorl %eax, %eax
subl %edx, %ecx
sbbl %eax, %eax
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
// File: dsesami[P]superscalar-processor-model/dispatch.cc
// Function: isiqfull()
bool isiqfull() {
    u_int empty_slots=IQ_SIZE;
    for(u_int i=0; i<IQ_SIZE; i++) {
        if(IQ.at(i).valid) empty_slots--;
    }
    return (empty_slots < WIDTH) ? true : false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x90b1(%rip), %rax      # 0x111c0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0x909b(%rip), %rcx      # 0x111c0
cmpl (%rcx), %eax
jae 0x8155
movl -0x8(%rbp), %eax
movl %eax, %esi
leaq 0x92e3(%rip), %rdi      # 0x11418
callq 0x3750
testb $0x1, (%rax)
je 0x8148
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x814a
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x811b
movl -0x4(%rbp), %ecx
leaq 0x9065(%rip), %rax      # 0x111c4
movl (%rax), %edx
xorl %eax, %eax
subl %edx, %ecx
sbbl %eax, %eax
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: dsesami[P]superscalar-processor-model/issue.cc
// Function: ready(unsigned int)
bool ready(u_int index) {
    bool status = true;
    if(IQ.at(index).instruction.rn_src_1 != -1) status = false;
    if(IQ.at(index).instruction.rn_src_2 != -1) status = false;
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movb $0x1, -0x5(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %esi
leaq 0x8f9d(%rip), %rdi      # 0x11418
callq 0x3750
cmpl $-0x1, 0x20(%rax)
je 0x848a
movb $0x0, -0x5(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %esi
leaq 0x8f82(%rip), %rdi      # 0x11418
callq 0x3750
cmpl $-0x1, 0x28(%rax)
je 0x84a5
movb $0x0, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
// File: dsesami[P]superscalar-processor-model/execute.cc
// Function: execute_needed()
bool execute_needed() {
    bool yes = false;
    for(u_int i=0; i<execute_list.size(); i++) {
        if(!execute_list.at(i).age) yes = true;
    }
    return yes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, -0x1(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
leaq 0x830f(%rip), %rdi      # 0x11430
callq 0x3730
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0x915a
movl -0x8(%rbp), %eax
movl %eax, %esi
leaq 0x82f2(%rip), %rdi      # 0x11430
callq 0x9260
cmpl $0x0, 0x78(%rax)
jne 0x914d
movb $0x1, -0x1(%rbp)
jmp 0x914f
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x9113
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: f18m[P]boost-intrusive-pool/tests/performance_tests.cpp
// Function: BenchPattern2String[abi:cxx11](BenchPattern_t)
std::string BenchPattern2String(BenchPattern_t t)
{
    switch (t) {
    case BENCH_PATTERN_CONTINUOUS_ALLOCATION:
        return "Continuous allocations, bulk free at end";
    case BENCH_PATTERN_MIXED_ALLOC_FREE:
        return "Mixed alloc/free pattern";
    default:
        return "";
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x34(%rsp)
testl %eax, %eax
je 0x23d6
jmp 0x23c8
movl 0x34(%rsp), %eax
subl $0x1, %eax
je 0x2429
jmp 0x2476
leaq 0x4b(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2270
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x7c4a(%rip), %rsi      # 0xa040
callq 0x2210
jmp 0x23fd
leaq 0x4b(%rsp), %rdi
callq 0x21b0
jmp 0x24c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4b(%rsp), %rdi
callq 0x21b0
jmp 0x24cd
leaq 0x3b(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2270
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x7c20(%rip), %rsi      # 0xa069
callq 0x2210
jmp 0x2450
leaq 0x3b(%rsp), %rdi
callq 0x21b0
jmp 0x24c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x3b(%rsp), %rdi
callq 0x21b0
jmp 0x24cd
leaq 0x3a(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2270
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x88be(%rip), %rsi      # 0xad54
callq 0x2210
jmp 0x249d
leaq 0x3a(%rsp), %rdi
callq 0x21b0
jmp 0x24c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x3a(%rsp), %rdi
callq 0x21b0
jmp 0x24cd
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x2260
nopw (%rax,%rax)
// File: f18m[P]boost-intrusive-pool/tests/performance_tests.cpp
// Function: main
int main(int argc, char** argv)
{
    if (argc > 1)
        usage(argv[0]);

    // to better simulate a realistic workload use our own benchmarking routines to
    // defrag a little bit the memory of this process (but do not really write any output!)
    for (unsigned int i = 0; i < 3; i++)
        do_benchmark(NULL);

    // final run is to write real output JSON
    do_json_benchmark();

    return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x1, 0x10(%rsp)
jle 0x2509
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x2540
movl $0x0, 0x4(%rsp)
cmpl $0x3, 0x4(%rsp)
jae 0x252e
xorl %eax, %eax
movl %eax, %edi
callq 0x2570
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2511
callq 0x3190
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: f18m[P]boost-intrusive-pool/tests/performance_tests.cpp
// Function: do_json_benchmark()
static void do_json_benchmark()
{
    json_ctx_t json_ctx;

    json_init(&json_ctx, 0, stdout);
    json_document_begin(&json_ctx);
    do_benchmark(&json_ctx);
    json_document_end(&json_ctx);

    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq 0xbe2d(%rip), %rax      # 0xefc8
movq (%rax), %rdx
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x9260
leaq 0x8(%rsp), %rdi
callq 0x92a0
leaq 0x8(%rsp), %rdi
callq 0x2570
leaq 0x8(%rsp), %rdi
callq 0x9360
leaq 0x7b84(%rip), %rdi      # 0xad53
movb $0x0, %al
callq 0x2050
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_document_begin(json_ctx*)
void json_document_begin(json_ctx_t* ctx)
{
    do_indent(ctx);

    fputs("{\n", ctx->fp);

    ctx->indent_level++;
    ctx->first_element = true;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x92e0
movq (%rsp), %rax
movq (%rax), %rsi
leaq 0x1a9f(%rip), %rdi      # 0xad5b
callq 0x21c0
movq (%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq (%rsp), %rax
movb $0x1, 0xc(%rax)
popq %rax
retq
nopl (%rax,%rax)
// File: f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: do_indent(json_ctx*)
static void do_indent(json_ctx_t* ctx)
{
    char indent_buf[ctx->indent_level + 1];

    memset(indent_buf, ' ', ctx->indent_level + 1);
    indent_buf[ctx->indent_level] = '\0';

    fputs(indent_buf, ctx->fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x10(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rsp
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0x20, %esi
callq 0x20e0
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movb $0x0, (%rdi,%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x21c0
movq -0x10(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_attr_object_begin(json_ctx*, char const*)
void json_attr_object_begin(json_ctx_t* ctx, const char* name)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ",\n");

    do_indent(ctx);

    fprintf(ctx->fp, "\"%s\": {\n", name);

    ctx->indent_level++;
    ctx->first_element = true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0xc(%rax)
jne 0x93bf
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x199a(%rip), %rsi      # 0xad52
movb $0x0, %al
callq 0x2220
movq 0x10(%rsp), %rdi
callq 0x92e0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x1978(%rip), %rsi      # 0xad55
movb $0x0, %al
callq 0x2220
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movb $0x1, 0xc(%rax)
addq $0x18, %rsp
retq
// File: f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_attr_object_end(json_ctx*)
void json_attr_object_end(json_ctx_t* ctx)
{
    ctx->indent_level--;
    ctx->first_element = false;

    fputs("\n", ctx->fp);

    do_indent(ctx);

    fputs("}", ctx->fp);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq (%rsp), %rax
movb $0x0, 0xc(%rax)
movq (%rsp), %rax
movq (%rax), %rsi
leaq 0x192b(%rip), %rdi      # 0xad53
callq 0x21c0
movq (%rsp), %rdi
callq 0x92e0
movq (%rsp), %rax
movq (%rax), %rsi
leaq 0x190c(%rip), %rdi      # 0xad50
callq 0x21c0
popq %rax
retq
nopl (%rax,%rax)
// File: f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_attr_string(json_ctx*, char const*, char const*)
void json_attr_string(json_ctx_t* ctx, const char* name, const char* s)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ",\n");
    else
        ctx->first_element = false;

    do_indent(ctx);

    fprintf(ctx->fp, "\"%s\": \"%s\"", name, s);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0xc(%rax)
jne 0x9485
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x18d6(%rip), %rsi      # 0xad52
movb $0x0, %al
callq 0x2220
jmp 0x948e
movq 0x10(%rsp), %rax
movb $0x0, 0xc(%rax)
movq 0x10(%rsp), %rdi
callq 0x92e0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x18ae(%rip), %rsi      # 0xad5e
movb $0x0, %al
callq 0x2220
addq $0x18, %rsp
retq
nopl (%rax)
// File: f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_attr_uint(json_ctx*, char const*, unsigned long)
void json_attr_uint(json_ctx_t* ctx, const char* name, uint64_t d)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ",\n");
    else
        ctx->first_element = false;

    do_indent(ctx);

    fprintf(ctx->fp, "\"%s\": %" PRIu64, name, d);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0xc(%rax)
jne 0x94f5
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x1866(%rip), %rsi      # 0xad52
movb $0x0, %al
callq 0x2220
jmp 0x94fe
movq 0x10(%rsp), %rax
movb $0x0, 0xc(%rax)
movq 0x10(%rsp), %rdi
callq 0x92e0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x1849(%rip), %rsi      # 0xad69
movb $0x0, %al
callq 0x2220
addq $0x18, %rsp
retq
nopl (%rax)
// File: f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_attr_int(json_ctx*, char const*, long)
void json_attr_int(json_ctx_t* ctx, const char* name, int64_t d)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ",\n");
    else
        ctx->first_element = false;

    do_indent(ctx);

    fprintf(ctx->fp, "\"%s\": %" PRId64, name, d);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0xc(%rax)
jne 0x9565
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x17f6(%rip), %rsi      # 0xad52
movb $0x0, %al
callq 0x2220
jmp 0x956e
movq 0x10(%rsp), %rax
movb $0x0, 0xc(%rax)
movq 0x10(%rsp), %rdi
callq 0x92e0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x17e3(%rip), %rsi      # 0xad73
movb $0x0, %al
callq 0x2220
addq $0x18, %rsp
retq
nopl (%rax)
// File: f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_attr_double(json_ctx*, char const*, double)
void json_attr_double(json_ctx_t* ctx, const char* name, double d)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ",\n");
    else
        ctx->first_element = false;

    do_indent(ctx);

    fprintf(ctx->fp, "\"%s\": %g", name, d);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0xc(%rax)
jne 0x95d6
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x1785(%rip), %rsi      # 0xad52
movb $0x0, %al
callq 0x2220
jmp 0x95df
movq 0x10(%rsp), %rax
movb $0x0, 0xc(%rax)
movq 0x10(%rsp), %rdi
callq 0x92e0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
movsd (%rsp), %xmm0
leaq 0x177b(%rip), %rsi      # 0xad7d
movb $0x1, %al
callq 0x2220
addq $0x18, %rsp
retq
nop
// File: f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_array_begin(json_ctx*, char const*)
void json_array_begin(json_ctx_t* ctx, const char* name)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ",\n");

    do_indent(ctx);

    fprintf(ctx->fp, "\"%s\": [", name);

    ctx->indent_level++;
    ctx->first_element = true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0xc(%rax)
jne 0x963f
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x171a(%rip), %rsi      # 0xad52
movb $0x0, %al
callq 0x2220
movq 0x10(%rsp), %rdi
callq 0x92e0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x1729(%rip), %rsi      # 0xad86
movb $0x0, %al
callq 0x2220
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movb $0x1, 0xc(%rax)
addq $0x18, %rsp
retq
// File: f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_element_string(json_ctx*, char const*)
void json_element_string(json_ctx_t* ctx, const char* s)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ", \"%s\"", s);
    else {
        fprintf(ctx->fp, "\"%s\"", s);
        ctx->first_element = false;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0xc(%rax)
jne 0x96e6
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x16b1(%rip), %rsi      # 0xad8e
movb $0x0, %al
callq 0x2220
jmp 0x970a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x1696(%rip), %rsi      # 0xad90
movb $0x0, %al
callq 0x2220
movq 0x10(%rsp), %rax
movb $0x0, 0xc(%rax)
addq $0x18, %rsp
retq
nop
// File: f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_element_uint(json_ctx*, unsigned long)
void json_element_uint(json_ctx_t* ctx, uint64_t d)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ", %" PRIu64, d);
    else {
        fprintf(ctx->fp, "%" PRIu64, d);
        ctx->first_element = false;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0xc(%rax)
jne 0x9746
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x1658(%rip), %rsi      # 0xad95
movb $0x0, %al
callq 0x2220
jmp 0x976a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x163d(%rip), %rsi      # 0xad97
movb $0x0, %al
callq 0x2220
movq 0x10(%rsp), %rax
movb $0x0, 0xc(%rax)
addq $0x18, %rsp
retq
nop
// File: f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_element_int(json_ctx*, long)
void json_element_int(json_ctx_t* ctx, int64_t d)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ", %" PRId64, d);
    else {
        fprintf(ctx->fp, "%" PRId64, d);
        ctx->first_element = false;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0xc(%rax)
jne 0x97a6
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x15fe(%rip), %rsi      # 0xad9b
movb $0x0, %al
callq 0x2220
jmp 0x97ca
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x15e3(%rip), %rsi      # 0xad9d
movb $0x0, %al
callq 0x2220
movq 0x10(%rsp), %rax
movb $0x0, 0xc(%rax)
addq $0x18, %rsp
retq
nop
// File: f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_element_double(json_ctx*, double)
void json_element_double(json_ctx_t* ctx, double d)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ", %g", d);
    else {
        fprintf(ctx->fp, "%g", d);
        ctx->first_element = false;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0xc(%rax)
jne 0x9808
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x15a2(%rip), %rsi      # 0xada1
movb $0x1, %al
callq 0x2220
jmp 0x982d
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x1586(%rip), %rsi      # 0xada3
movb $0x1, %al
callq 0x2220
movq 0x10(%rsp), %rax
movb $0x0, 0xc(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_element_object_begin(json_ctx*)
void json_element_object_begin(json_ctx_t* ctx)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ",");

    fputs("\n", ctx->fp);

    do_indent(ctx);

    fputs("{\n", ctx->fp);

    ctx->indent_level++;
    ctx->first_element = true;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
testb $0x1, 0xc(%rax)
jne 0x9864
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x1549(%rip), %rsi      # 0xada6
movb $0x0, %al
callq 0x2220
movq (%rsp), %rax
movq (%rax), %rsi
leaq 0x14e1(%rip), %rdi      # 0xad53
callq 0x21c0
movq (%rsp), %rdi
callq 0x92e0
movq (%rsp), %rax
movq (%rax), %rsi
leaq 0x14cd(%rip), %rdi      # 0xad5b
callq 0x21c0
movq (%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq (%rsp), %rax
movb $0x1, 0xc(%rax)
popq %rax
retq
nopw (%rax,%rax)
// File: Dalgona[P]mine/reset-scores.cpp
// Function: main
int main(void)
{
  std::cout << "Opening scores.dat for writing...\n";
  std::ofstream file("scores.dat", std::ios::out | std::ios::binary);
  std::cout << "Writing blank score data...\n";
  for (int i = 0; i < 15; i++)
  {
    file << "__________";
    file.write("\x00\xff\xff\xff\x7f", 5);
  }
  std::cout << "Closing file...\n";
  file.close();
  std::cout << "Score data were reset successfully.\n";
  return 0;
}

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movl $0x0, 0x224(%rsp)
movq 0x2dcf(%rip), %rdi      # 0x3fd8
movq %rdi, 0x8(%rsp)
leaq 0xdef(%rip), %rsi       # 0x2004
callq 0x1040
movl $0x10, %edi
movl $0x4, %esi
callq 0x1320
movl %eax, %edx
leaq 0xdf5(%rip), %rsi       # 0x2027
leaq 0x20(%rsp), %rdi
callq 0x1050
movq 0x8(%rsp), %rdi
leaq 0xdea(%rip), %rsi       # 0x2032
callq 0x1040
jmp 0x124f
movl $0x0, 0x10(%rsp)
cmpl $0xf, 0x10(%rsp)
jge 0x12b2
leaq 0xdea(%rip), %rsi       # 0x204f
leaq 0x20(%rsp), %rdi
callq 0x1040
jmp 0x1271
leaq 0xe18(%rip), %rsi       # 0x2090
leaq 0x20(%rsp), %rdi
movl $0x5, %edx
callq 0x1060
jmp 0x1289
jmp 0x128b
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1257
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1080
jmp 0x130c
movq 0x2d1f(%rip), %rdi      # 0x3fd8
leaq 0xd9a(%rip), %rsi       # 0x205a
callq 0x1040
jmp 0x12c7
leaq 0x20(%rsp), %rdi
callq 0x1070
jmp 0x12d3
movq 0x2cfe(%rip), %rdi      # 0x3fd8
leaq 0xd8a(%rip), %rsi       # 0x206b
callq 0x1040
jmp 0x12e8
movl $0x0, 0x224(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1080
movl 0x224(%rsp), %eax
addq $0x228, %rsp            # imm = 0x228
retq
movq 0x18(%rsp), %rdi
callq 0x10a0
nopw %cs:(%rax,%rax)
// File: pdx-cs-tutors[P]pdp/tests/base_test.cpp
// Function: stringify[abi:cxx11](std::vector<int, std::allocator<int>>)
std::string stringify(std::vector<int> values) {
    std::stringstream ss;
    ss << "[";
    if (values.size() > 0) {
        std::copy(values.begin(), values.end() - 1, std::ostream_iterator<int>(ss, " -> "));
        ss << *(values.end() - 1);
    }
    ss << "]";
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rsi, -0x208(%rbp)
movq %rdi, -0x200(%rbp)
movq %rdi, %rax
movq %rax, -0x1f8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x1ed10
leaq -0x188(%rbp), %rdi
leaq 0x2231b(%rip), %rsi     # 0x43000
callq 0x1f440
jmp 0x20cec
movq -0x208(%rbp), %rdi
callq 0x208c0
cmpq $0x0, %rax
jbe 0x20df6
movq -0x208(%rbp), %rdi
callq 0x1e7d0
movq -0x208(%rbp), %rdi
movq %rax, -0x1b0(%rbp)
callq 0x1ed40
movq %rax, -0x1c0(%rbp)
leaq -0x1c0(%rbp), %rdi
movl $0x1, %esi
callq 0x20420
movq %rax, -0x1b8(%rbp)
leaq -0x188(%rbp), %rsi
leaq 0x222b4(%rip), %rdx     # 0x43002
leaq -0x1d0(%rbp), %rdi
callq 0x1eab0
jmp 0x20d5c
movq -0x1b0(%rbp), %rsi
movq -0x1b8(%rbp), %rdx
leaq -0x1e0(%rbp), %rdi
leaq -0x1d0(%rbp), %rcx
callq 0x1f760
jmp 0x20d7f
movq -0x208(%rbp), %rdi
leaq -0x188(%rbp), %rax
movq %rax, -0x210(%rbp)
callq 0x1ed40
movq %rax, -0x1f0(%rbp)
leaq -0x1f0(%rbp), %rdi
movl $0x1, %esi
callq 0x20420
movq %rax, -0x1e8(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x1fea0
movq -0x210(%rbp), %rdi
movl (%rax), %esi
callq 0x20410
jmp 0x20dd4
jmp 0x20df6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x1edc0
jmp 0x20e3c
leaq -0x188(%rbp), %rdi
leaq 0x229d4(%rip), %rsi     # 0x437d8
callq 0x1f440
jmp 0x20e0b
movq -0x200(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x1f410
jmp 0x20e20
leaq -0x198(%rbp), %rdi
callq 0x1edc0
movq -0x1f8(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x20540
nopl (%rax,%rax)
// File: pdx-cs-tutors[P]pdp/tests/base_test.cpp
// Function: stringify[abi:cxx11](std::initializer_list<int>)
std::string stringify(std::initializer_list<int> values) {
    std::stringstream ss;
    ss << "[";
    if (values.size() > 0) {
        std::copy(values.begin(), values.end() - 1, std::ostream_iterator<int>(ss, " -> "));
        ss << *(values.end() - 1);
    }
    ss << "]";
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x1ed10
leaq -0x190(%rbp), %rdi
leaq 0x2216e(%rip), %rsi     # 0x43000
callq 0x1f440
jmp 0x20e99
leaq -0x18(%rbp), %rdi
callq 0x1fab0
cmpq $0x0, %rax
jbe 0x20f63
leaq -0x18(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x1f530
movq -0x1f8(%rbp), %rdi
movq %rax, -0x1f0(%rbp)
callq 0x1f150
addq $-0x4, %rax
movq %rax, -0x1e8(%rbp)
leaq -0x190(%rbp), %rsi
leaq 0x2211a(%rip), %rdx     # 0x43002
leaq -0x1c0(%rbp), %rdi
callq 0x1eab0
jmp 0x20ef6
movq -0x1e8(%rbp), %rdx
movq -0x1f0(%rbp), %rsi
leaq -0x1d0(%rbp), %rdi
leaq -0x1c0(%rbp), %rcx
callq 0x1e080
jmp 0x20f19
leaq -0x190(%rbp), %rax
movq %rax, -0x200(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1f150
movq -0x200(%rbp), %rdi
movl -0x4(%rax), %esi
callq 0x20410
jmp 0x20f41
jmp 0x20f63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x1edc0
jmp 0x20fa9
leaq -0x190(%rbp), %rdi
leaq 0x22867(%rip), %rsi     # 0x437d8
callq 0x1f440
jmp 0x20f78
movq -0x1e0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x1f410
jmp 0x20f8d
leaq -0x1a0(%rbp), %rdi
callq 0x1edc0
movq -0x1d8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x20540
nopw %cs:(%rax,%rax)
// File: pdx-cs-tutors[P]pdp/tests/base_test.cpp
// Function: BaseFailure::report() const
void BaseFailure::report() const {
    std::cout << termcolor::on_red << termcolor::bold << " FAILED " << termcolor::reset
              << " " << description << std::endl
              << "Initial:  " << initial << std::endl
              << "Called:   " << termcolor::bold << call << termcolor::reset << std::endl
              << "Expected: " << expected << std::endl
              << "Got:      " << actual << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x37fcd(%rip), %rdi     # 0x58fa8
movq 0x37fee(%rip), %rsi     # 0x58fd0
callq 0x1f510
movq %rax, %rdi
movq 0x37f97(%rip), %rsi     # 0x58f88
callq 0x1f510
movq %rax, %rdi
leaq 0x22007(%rip), %rsi     # 0x43007
callq 0x1f440
movq %rax, %rdi
movq 0x37fb9(%rip), %rsi     # 0x58fc8
callq 0x1f510
movq %rax, %rdi
leaq 0x2201c(%rip), %rsi     # 0x4303a
callq 0x1f440
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x1f170
movq %rax, %rdi
movq 0x37f33(%rip), %rsi     # 0x58f70
callq 0x1f510
movq %rax, %rdi
leaq 0x21fc4(%rip), %rsi     # 0x43010
callq 0x1f440
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x48, %rsi
callq 0x1f170
movq %rax, %rdi
movq 0x37f05(%rip), %rsi     # 0x58f70
callq 0x1f510
movq %rax, %rdi
leaq 0x21fa1(%rip), %rsi     # 0x4301b
callq 0x1f440
movq %rax, %rdi
movq 0x37eff(%rip), %rsi     # 0x58f88
callq 0x1f510
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x28, %rsi
callq 0x1f170
movq %rax, %rdi
movq 0x37f20(%rip), %rsi     # 0x58fc8
callq 0x1f510
movq %rax, %rdi
movq 0x37eb9(%rip), %rsi     # 0x58f70
callq 0x1f510
movq %rax, %rdi
leaq 0x21f60(%rip), %rsi     # 0x43026
callq 0x1f440
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x68, %rsi
callq 0x1f170
movq %rax, %rdi
movq 0x37e8b(%rip), %rsi     # 0x58f70
callq 0x1f510
movq %rax, %rdi
leaq 0x21f3d(%rip), %rsi     # 0x43031
callq 0x1f440
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x88, %rsi
callq 0x1f170
movq %rax, %rdi
movq 0x37e5a(%rip), %rsi     # 0x58f70
callq 0x1f510
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pdx-cs-tutors[P]pdp/tests/include/termcolor.h
// Function: termcolor::_internal::get_standard_stream(std::ostream const&)
inline
        FILE* get_standard_stream(const std::ostream& stream)
        {
            if (&stream == &std::cout)
                return stdout;
            else if ((&stream == &std::cerr) || (&stream == &std::clog))
                return stderr;

            return 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq 0x36819(%rip), %rax     # 0x58fa8
cmpq %rax, -0x10(%rbp)
jne 0x227a5
movq 0x3678c(%rip), %rax     # 0x58f28
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x227d9
movq 0x36844(%rip), %rax     # 0x58ff0
cmpq %rax, -0x10(%rbp)
je 0x227bf
movq 0x36797(%rip), %rax     # 0x58f50
cmpq %rax, -0x10(%rbp)
jne 0x227cf
movq 0x367fa(%rip), %rax     # 0x58fc0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x227d9
jmp 0x227d1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: pdx-cs-tutors[P]pdp/tests/cll/cll_test.cpp
// Function: stringify[abi:cxx11](cll::node*)
std::string stringify(cll::node* rear) {
    if (!rear) return "[]";
    cll::node* current = rear->next;
    std::stringstream ss;
    ss << "[";
    if (rear->next == rear) {
        ss << rear->data << "]";
        return ss.str();
    }
    do {
        ss << current->data;
        if (current->next != rear) ss << " -> ";
        current = current->next;
    } while (current != rear);
    ss << " -> " << rear->data << "]";
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3058f
leaq -0x11(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x20560
movq -0x1d0(%rbp), %rdi
movq -0x1d8(%rbp), %rdx
leaq 0x13277(%rip), %rsi     # 0x437d7
callq 0x1fc60
jmp 0x30567
leaq -0x11(%rbp), %rdi
callq 0x1f620
jmp 0x30703
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x1f620
jmp 0x30713
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1ed10
leaq -0x1a8(%rbp), %rdi
leaq 0x12a4b(%rip), %rsi     # 0x43000
callq 0x1f440
jmp 0x305bc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x3063b
leaq -0x1a8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x20410
movq %rax, -0x1e0(%rbp)
jmp 0x305e5
movq -0x1e0(%rbp), %rdi
leaq 0x131e5(%rip), %rsi     # 0x437d8
callq 0x1f440
jmp 0x305fa
movq -0x1d0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x1f410
jmp 0x3060f
movl $0x1, -0x1bc(%rbp)
jmp 0x306f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1edc0
jmp 0x30713
jmp 0x3063d
leaq -0x1a8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl (%rax), %esi
callq 0x20410
jmp 0x30651
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x30676
leaq -0x1a8(%rbp), %rdi
leaq 0x12995(%rip), %rsi     # 0x43002
callq 0x1f440
jmp 0x30674
jmp 0x30676
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x3063d
leaq -0x1a8(%rbp), %rdi
leaq 0x12968(%rip), %rsi     # 0x43002
callq 0x1f440
movq %rax, -0x1e8(%rbp)
jmp 0x306a8
movq -0x1e8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x20410
movq %rax, -0x1f0(%rbp)
jmp 0x306c3
movq -0x1f0(%rbp), %rdi
leaq 0x13107(%rip), %rsi     # 0x437d8
callq 0x1f440
jmp 0x306d8
movq -0x1d0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x1f410
jmp 0x306ed
movl $0x1, -0x1bc(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x1edc0
movq -0x1c8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x20540
nopl (%rax)
// File: pdx-cs-tutors[P]pdp/tests/cll/cll_test.cpp
// Function: destroy_cll(cll::node*&)
void destroy_cll(cll::node*& rear) {
    if (rear == nullptr) return;
    cll::node* curr = rear;
    while (curr->next != rear) {
        cll::node* temp = curr->next;
        curr->next = temp->next;
        delete temp;
        temp = nullptr;
    }
    delete rear;
    rear = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x30738
jmp 0x307b6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x30791
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x30787
movq -0x20(%rbp), %rdi
callq 0x1f2f0
movq $0x0, -0x18(%rbp)
jmp 0x30743
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x307ab
movq -0x28(%rbp), %rdi
callq 0x1f2f0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: pdx-cs-tutors[P]pdp/tests/cll/cll_test.cpp
// Function: CLLTestSuite::tearDown()
void CLLTestSuite::tearDown() {
    BaseTestSuite::tearDown();
    if (rear) destroy_cll(rear);
    rear = nullptr;
    initial = {};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1f7e0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x30c51
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
callq 0x1f1c0
movq -0x20(%rbp), %rax
movq $0x0, 0x78(%rax)
leaq -0x18(%rbp), %rdi
callq 0x1f9d0
movq -0x20(%rbp), %rdi
addq $0x80, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x1f1a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pdx-cs-tutors[P]pdp/tests/cll/cll_test.cpp
// Function: CLLTestSuite::initialize(std::initializer_list<int>)
void CLLTestSuite::initialize(std::initializer_list<int> values) {
    rear = nullptr;
    for (auto it = values.end(); it != values.begin();) {
        if (!rear) {
            rear = new cll::node();
            rear->data = *--it;
            rear->next = rear;
        } else {
            cll::node* temp = rear->next;
            rear->next = new cll::node();
            rear->next->data = *--it;
            rear->next->next = temp;
        }
    }
    initial = values;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, 0x78(%rax)
leaq -0x10(%rbp), %rdi
callq 0x1f150
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1f530
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0x30daa
movq -0x40(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x30d3c
movl $0x10, %edi
callq 0x1f470
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x1ea00
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $-0x4, %rdx
movq %rdx, -0x20(%rbp)
movl -0x4(%rcx), %edx
movq 0x78(%rax), %rcx
movl %edx, (%rcx)
movq 0x78(%rax), %rcx
movq 0x78(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x30da5
movq -0x40(%rbp), %rax
movq 0x78(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x10, %edi
callq 0x1f470
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x1ea00
movq -0x58(%rbp), %rdx
movq -0x40(%rbp), %rax
movq 0x78(%rax), %rcx
movq %rdx, 0x8(%rcx)
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $-0x4, %rdx
movq %rdx, -0x20(%rbp)
movl -0x4(%rcx), %edx
movq 0x78(%rax), %rcx
movq 0x8(%rcx), %rcx
movl %edx, (%rcx)
movq -0x28(%rbp), %rcx
movq 0x78(%rax), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x30cc1
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x80, %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1f1a0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: pdx-cs-tutors[P]pdp/tests/cll/cll_test.cpp
// Function: CLLTestSuite::expectReturn(int)
void CLLTestSuite::expectReturn(int value) {
    if (retval == nullptr || *retval != value) {
        addFailure(CLLReturnFailure(
            "Incorrect return value",
            call,
            initial,
            value,
            *retval
        ));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
cmpq $0x0, 0x50(%rax)
je 0x3137a
movq -0xf0(%rbp), %rax
movq 0x50(%rax), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x3143c
movq -0xf0(%rbp), %rsi
addq $0x58, %rsi
leaq -0xd8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x1e810
movq -0xf0(%rbp), %rax
movq -0xf8(%rbp), %rdx
movq %rax, %rcx
subq $-0x80, %rcx
movl -0xc(%rbp), %r8d
movq 0x50(%rax), %rax
movl (%rax), %r9d
leaq 0x1244d(%rip), %rsi     # 0x4380c
leaq -0xb8(%rbp), %rdi
callq 0x20260
jmp 0x313cd
movq -0xf0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x1f9b0
jmp 0x313e2
leaq -0xb8(%rbp), %rdi
callq 0x1fe50
leaq -0xd8(%rbp), %rdi
callq 0x1eba0
jmp 0x3143c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x3142e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x1fe50
leaq -0xd8(%rbp), %rdi
callq 0x1eba0
jmp 0x31445
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xe0(%rbp), %rdi
callq 0x20540
nopw %cs:(%rax,%rax)
// File: pdx-cs-tutors[P]pdp/tests/lll/lll_test.cpp
// Function: stringify[abi:cxx11](lll::node*)
std::string stringify(lll::node* head) {
    std::stringstream ss;
    ss << "[";
    while (head) {
        ss << head->data;
        if (head->next) ss << " -> ";
        head = head->next;
    }
    ss << "]";
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x1ed10
leaq -0x188(%rbp), %rdi
leaq 0x6792(%rip), %rsi      # 0x43000
callq 0x1f440
jmp 0x3c875
jmp 0x3c877
cmpq $0x0, -0x10(%rbp)
je 0x3c8e2
leaq -0x188(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x20410
jmp 0x3c892
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3c8d4
leaq -0x188(%rbp), %rdi
leaq 0x6757(%rip), %rsi      # 0x43002
callq 0x1f440
jmp 0x3c8b2
jmp 0x3c8d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x1edc0
jmp 0x3c928
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3c877
leaq -0x188(%rbp), %rdi
leaq 0x6ee8(%rip), %rsi      # 0x437d8
callq 0x1f440
jmp 0x3c8f7
movq -0x1b8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x1f410
jmp 0x3c90c
leaq -0x198(%rbp), %rdi
callq 0x1edc0
movq -0x1b0(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x20540
nopw %cs:(%rax,%rax)
// File: pdx-cs-tutors[P]pdp/tests/lll/lll_test.cpp
// Function: destroy_lll(lll::node*)
void destroy_lll(lll::node* head) {
    while (head) {
        lll::node* temp = head->next;
        delete head;
        head = temp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3c980
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3c976
movq -0x18(%rbp), %rdi
callq 0x1f2f0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3c94c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pdx-cs-tutors[P]pdp/tests/lll/lll_test.cpp
// Function: LLLTestSuite::tearDown()
void LLLTestSuite::tearDown() {
    if (head) destroy_lll(head);
    head = nullptr;// Verify that the nodes in the LLL match the given values
// e.g. expectList(head, {1, 2, 3});
// Add failures if there are discrepancies
    if (retval) delete retval;
    retval = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x78(%rax)
je 0x3ce98
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x1f850
movq -0x10(%rbp), %rax
movq $0x0, 0x78(%rax)
cmpq $0x0, 0x50(%rax)
je 0x3cec8
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3cec6
movq -0x18(%rbp), %rdi
callq 0x1f2f0
jmp 0x3cec8
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pdx-cs-tutors[P]pdp/tests/lll/lll_test.cpp
// Function: LLLTestSuite::expectReturn(int)
void LLLTestSuite::expectReturn(int value) {
    if (retval == nullptr || *retval != value) {
        addFailure(LLLReturnFailure(
            "Incorrect return value",
            call,
            initial,
            value,
            *retval
        ));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
cmpq $0x0, 0x50(%rax)
je 0x3d2fa
movq -0xf0(%rbp), %rax
movq 0x50(%rax), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x3d3bc
movq -0xf0(%rbp), %rsi
addq $0x58, %rsi
leaq -0xd8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x1e810
movq -0xf0(%rbp), %rax
movq -0xf8(%rbp), %rdx
movq %rax, %rcx
subq $-0x80, %rcx
movl -0xc(%rbp), %r8d
movq 0x50(%rax), %rax
movl (%rax), %r9d
leaq 0x64cd(%rip), %rsi      # 0x4380c
leaq -0xb8(%rbp), %rdi
callq 0x1fac0
jmp 0x3d34d
movq -0xf0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x1ef90
jmp 0x3d362
leaq -0xb8(%rbp), %rdi
callq 0x1f660
leaq -0xd8(%rbp), %rdi
callq 0x1eba0
jmp 0x3d3bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x3d3ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x1f660
leaq -0xd8(%rbp), %rdi
callq 0x1eba0
jmp 0x3d3c5
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xe0(%rbp), %rdi
callq 0x20540
nopw %cs:(%rax,%rax)
// File: pdx-cs-tutors[P]pdp/tests/lll/lll_test.cpp
// Function: LLLTestSuite::initialize(std::initializer_list<int>)
void LLLTestSuite::initialize(std::initializer_list<int> values) {
    head = nullptr;
    for (auto it = values.end(); it != values.begin();) {
        lll::node* temp = head;
        head = new lll::node();
        head->data = *--it;
        head->next = temp;
    }
    initial = values;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, 0x78(%rax)
leaq -0x10(%rbp), %rdi
callq 0x1f150
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1f530
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0x3d509
movq -0x40(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x10, %edi
callq 0x1f470
movq %rax, %rdi
movq %rdi, -0x50(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x1ea00
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $-0x4, %rdx
movq %rdx, -0x20(%rbp)
movl -0x4(%rcx), %edx
movq 0x78(%rax), %rcx
movl %edx, (%rcx)
movq -0x28(%rbp), %rcx
movq 0x78(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x3d491
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x80, %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1f1a0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: linuxnoodle[P]typer/main.cpp
// Function: generateString[abi:cxx11](int)
string generateString(int wordCount){
    string generated;
    for (int i = 0; i < wordCount; ++i){
        generated += words[distribution(generator)];
        if (i != wordCount - 1){
            generated += " ";
        }
    }
    return generated;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movb $0x0, 0x3b(%rsp)
callq 0x3360
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x3704
leaq 0x7f8f(%rip), %rdi      # 0xb610
leaq 0x6c00(%rip), %rsi      # 0xa288
callq 0x4610
movq %rax, 0x8(%rsp)
jmp 0x3694
movq 0x8(%rsp), %rsi
leaq 0x6bd0(%rip), %rdi      # 0xa270
callq 0x45f0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3350
jmp 0x36b4
movl 0x34(%rsp), %eax
movl 0x3c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x36f2
movq 0x10(%rsp), %rdi
leaq 0x3a92(%rip), %rsi      # 0x7161
callq 0x3280
jmp 0x36d6
jmp 0x36f2
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x31b0
jmp 0x3724
jmp 0x36f4
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x366c
movb $0x1, 0x3b(%rsp)
testb $0x1, 0x3b(%rsp)
jne 0x371a
movq 0x10(%rsp), %rdi
callq 0x31b0
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x3410
nop