LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testKeySerialization()
void testKeySerialization() {
    Sys* system = new Sys();
    Key* v1 = new Key("muffin", 0);
    Key* v3 = new Key("carrot", 0);
    char* serialized = v1->serialize();
    Key* v2 = new Key(serialized);
    system->t_true(v1->equals(v2));
    system->t_false(v3->equals(v2));
    system->OK("Passed Key serialization");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
movl $0x20, %edi
callq 0x7200
movq %rax, %r14
leaq 0x17243(%rip), %rsi     # 0x20090
movq %rax, %rdi
xorl %edx, %edx
callq 0xac04
movl $0x20, %edi
callq 0x7200
movq %rax, %r15
leaq 0x1722c(%rip), %rsi     # 0x20097
movq %rax, %rdi
xorl %edx, %edx
callq 0xac04
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, %r13
movl $0x20, %edi
callq 0x7200
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0xe4da
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x18(%rax)
testb %al, %al
je 0x8ede
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x8ede
leaq 0x174b2(%rip), %rsi     # 0x20372
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x177df(%rip), %rsi     # 0x206c4
movq %rbx, %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r12, %r14
jmp 0x8f0a
movq %rax, %rbx
movq %r15, %r14
jmp 0x8f0a
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testKVStoreSerialization()
void testKVStoreSerialization() {
    Sys* system = new Sys();
    KVStore* kvs1 = tempStore();
    char* serialized = kvs1->serialize();
    KVStore* kvs2 = new KVStore(serialized);
    char* serialized2 = kvs2->serialize();
    String* s = new String(serialized);
    String* s2 = new String(serialized2);
    system->t_true(s2->equals(s));
    //system->t_true(kvs2->get(k1)->equals(v1));
    system->OK("Passed KVStore serialization");
    delete kvs1;
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x1, %edi
callq 0x7200
movq %rax, -0x30(%rbp)
callq 0x74ec
movq %rax, %rdi
movq (%rax), %rax
movq %rdi, -0x40(%rbp)
callq *0x38(%rax)
movq %rax, %r13
movl $0x118, %edi            # imm = 0x118
callq 0x7200
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
callq 0xe670
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, -0x38(%rbp)
movl $0x20, %edi
callq 0x7200
movq %rax, %r15
movq %r13, %rdi
callq 0x70f0
movq %rax, %rbx
movq $0x0, 0x8(%r15)
leaq 0x22516(%rip), %rax     # 0x2b4b0
movq %rax, (%r15)
movq %rbx, 0x10(%r15)
leaq 0x1(%rbx), %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %r14
movq %rax, 0x18(%r15)
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7180
movb $0x0, (%r14,%rbx)
movl $0x20, %edi
callq 0x7200
movq %rax, %r13
movq -0x38(%rbp), %rdi
callq 0x70f0
movq %rax, %rbx
movq $0x0, 0x8(%r13)
leaq 0x224c1(%rip), %rax     # 0x2b4b0
movq %rax, (%r13)
movq %rbx, 0x10(%r13)
leaq 0x1(%rbx), %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %r14
movq %rax, 0x18(%r13)
movq %rax, %rdi
movq -0x38(%rbp), %rsi
movq %r12, %rdx
callq 0x7180
movb $0x0, (%r14,%rbx)
movq %r13, %rdi
movq %r15, %rsi
callq 0x11406
testb %al, %al
je 0x9060
leaq 0x17357(%rip), %rsi     # 0x2038b
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x12738
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x1765d(%rip), %rsi     # 0x206c4
movq -0x30(%rbp), %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
movq %rax, %rbx
movq %r13, %r15
jmp 0x9087
jmp 0x9084
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testSchema()
void testSchema() {
    Sys* system = new Sys();
    Schema* sch = new Schema("IFD");
    char* serialized = sch->serialize();
    //std::cout << serialized << "\n";
    Schema* sch2 = new Schema(serialized);
    //std::cout << sch2->serialize() << "\n";
    String* s = new String(serialized);
    String* s2 = new String(sch2->serialize());
    system->t_true(s2->equals(s));

    system->OK("Passed Schema");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
movl $0x50, %edi
callq 0x7200
movq %rax, %r15
leaq 0x16073(%rip), %rsi     # 0x20493
movq %rax, %rdi
callq 0x10404
movq %rbx, -0x30(%rbp)
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r12
movl $0x50, %edi
callq 0x7200
movq %rax, -0x38(%rbp)
movq %rax, %rdi
movq %r12, %rsi
callq 0x10598
movl $0x20, %edi
callq 0x7200
movq %rax, %r15
movq %r12, %rdi
callq 0x70f0
movq %rax, %r13
movq $0x0, 0x8(%r15)
leaq 0x21038(%rip), %rax     # 0x2b4b0
movq %rax, (%r15)
movq %r13, 0x10(%r15)
leaq 0x1(%r13), %rbx
movq %rbx, %rdi
callq 0x7030
movq %rax, %r14
movq %r15, -0x40(%rbp)
movq %rax, 0x18(%r15)
movq %rax, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x7180
movb $0x0, (%r14,%r13)
movl $0x20, %edi
callq 0x7200
movq %rax, %r15
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %r12
movq %rax, %rdi
callq 0x70f0
movq %rax, %r13
movq $0x0, 0x8(%r15)
leaq 0x20fd3(%rip), %rax     # 0x2b4b0
movq %rax, (%r15)
movq %r13, 0x10(%r15)
leaq 0x1(%r13), %rbx
movq %rbx, %rdi
callq 0x7030
movq %rax, %r14
movq %rax, 0x18(%r15)
movq %rax, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x7180
movb $0x0, (%r14,%r13)
movq %r15, %rdi
movq -0x40(%rbp), %rsi
callq 0x11406
testb %al, %al
je 0xa543
leaq 0x15f76(%rip), %rsi     # 0x20497
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7270
leaq 0x1617a(%rip), %rsi     # 0x206c4
movq -0x30(%rbp), %rdi
callq 0x12738
movl $0x1, %edi
callq 0x7260
jmp 0xa56a
movq %rax, %rbx
movq -0x38(%rbp), %r15
jmp 0xa56d
jmp 0xa56a
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testApplication()
void testApplication() {
    Sys* system = new Sys();
    NetworkIP network;
    Trivial* triv = new Trivial(0, &network);
    triv->run_();

    system->OK("Passed Application code M2");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl $0x1, %edi
callq 0x7200
movq %rax, %rbx
xorl %eax, %eax
movq %rax, -0x58(%rbp)
leaq 0x20cf7(%rip), %r15     # 0x2b580
movq %r15, -0x60(%rbp)
movq $0x1, -0x48(%rbp)
movq %rax, -0x40(%rbp)
movq %rax, -0x20(%rbp)
movl $0x20, %edi
callq 0x7200
movq %rax, %r14
leaq -0x60(%rbp), %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1c0a0
leaq 0x223b9(%rip), %rax     # 0x2cc78
movq %rax, (%r14)
movq %r14, %rdi
callq 0x1c11a
leaq 0x15bf0(%rip), %rsi     # 0x204c1
movq %rbx, %rdi
callq 0x12738
movq %rbx, %rdi
callq 0x7270
movq %r15, -0x60(%rbp)
movl -0x38(%rbp), %edi
callq 0x7370
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa91e
movq %rax, %rbx
movq %r14, %rdi
callq 0x71d0
jmp 0xa90a
movq %rax, %rbx
movq %r15, -0x60(%rbp)
movl -0x38(%rbp), %edi
callq 0x7370
movq %rbx, %rdi
callq 0x7350
movq %rax, %rdi
callq 0x11518
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/testSerialize.cpp
// Function: main
int main() {
    testValueSerialization();
    testKeySerialization();
    testIntArraySerialization();
    testIntColumnSerialization();
    testStringArraySerialization();
    testStringColumnSerialization();
    testFloatArraySerialization();
    testFloatColumnSerialization();
    testMessageSerialization();
    testAckSerialization();
    testNackSerialization();
    testPutSerialization();
    testGetSerialization();
    testWaitAndGetSerialization();
    testStatusSerialization();
    testReplySerialization();
    testRegisterSerialization();
    testDirectorySerialization();
    testIntDistributedArrays();
    testStringDistributedArrays();
    testFloatDistributedArrays();
    testDistributedIntColumn();
    testDistributedDoubleColumn();
    testDistributedFloatColumn();
    testDistributedBoolColumn();
    testDistributedStringColumn();
    testSchema();
    testDistributedDataframe();
    testApplication();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x8d15
callq 0x8e1e
callq 0x804b
callq 0x815a
callq 0x79bf
callq 0x7c08
callq 0x7e34
callq 0x7f4c
callq 0x8259
callq 0x8353
callq 0x8431
callq 0x850f
callq 0x8634
callq 0x872b
callq 0x8822
callq 0x890b
callq 0x89f4
callq 0x8ae5
callq 0x9097
callq 0x9301
callq 0x95d9
callq 0x9872
callq 0x9abe
callq 0x9d0a
callq 0x9f56
callq 0xa1a2
callq 0xa3ee
callq 0xa57d
callq 0xa862
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/./../src/dataframe/column.h
// Function: FloatColumn::FloatColumn(int, ...)
FloatColumn(int n, ...) {
    val_ = new Array();
    for(int i = 0; i < metaArrayStartSize_; i++) {
      val_->pushBack(new FloatArray(arraySize_));
    }
    va_list ap;
    va_start (ap, n);
    for (int i = 0; i < n; i++) {
      push_back(va_arg (ap, float)); 
    }
    va_end (ap);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdx, -0xe0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %r8, -0xd0(%rbp)
movq %r9, -0xc8(%rbp)
testb %al, %al
je 0xb157
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
xorl %r12d, %r12d
movq %r12, 0x8(%rdi)
leaq 0x20843(%rip), %rax     # 0x2b9a8
movq %rax, (%rdi)
movabsq $0x40000000000, %rax    # imm = 0x40000000000
movq %rax, 0x18(%rdi)
movl $0xa, 0x20(%rdi)
movl $0x28, %edi
callq 0x7200
movq %rax, %r15
movq %r12, 0x8(%rax)
leaq 0x205eb(%rip), %rax     # 0x2b780
movq %rax, (%r15)
movl $0x28, %edi
callq 0x7030
movq %rax, 0x10(%r15)
movq $0x5, 0x20(%r15)
movq $0x0, 0x18(%r15)
movq %r15, 0x10(%r14)
xorl %r13d, %r13d
movq 0x10(%r14), %r12
movl $0x28, %edi
callq 0x7200
movq %rax, %r15
movslq 0x1c(%r14), %rax
leaq (,%rax,4), %rdi
testq %rax, %rax
movl $0x0, %ecx
movq %rcx, 0x8(%r15)
leaq 0x2076b(%rip), %rdx     # 0x2b958
movq %rdx, (%r15)
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
movq $-0x1, %rax
cmovsq %rax, %rdi
callq 0x7030
movq %rax, 0x10(%r15)
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x58(%rax)
incl %r13d
cmpl 0x20(%r14), %r13d
jl 0xb1bd
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x40(%rbp)
testl %ebx, %ebx
jle 0xb282
movl -0x3c(%rbp), %ecx
cmpq $0xa0, %rcx
ja 0xb262
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x10, %ecx
movl %ecx, -0x3c(%rbp)
jmp 0xb26e
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movss (%rax), %xmm0
movq (%r14), %rax
movq %r14, %rdi
callq *0xb0(%rax)
decl %ebx
jne 0xb247
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb296
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/./../src/dataframe/column.h
// Function: IntColumn::IntColumn(int, ...)
IntColumn(int n, ...) {
    val_ = new Array();
    for(int i = 0; i < metaArrayStartSize_; i++) {
      val_->pushBack(new IntArray(arraySize_));
    }
    va_list ap;
    va_start (ap, n);
    for (int i = 0; i < n; i++) {
      push_back(va_arg (ap, int)); 
    }
    va_end (ap);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rdx, -0xe0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %r8, -0xd0(%rbp)
movq %r9, -0xc8(%rbp)
testb %al, %al
je 0xb30f
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
xorl %r12d, %r12d
movq %r12, 0x8(%rdi)
leaq 0x207c3(%rip), %rax     # 0x2bae0
movq %rax, (%rdi)
movabsq $0x40000000000, %rax    # imm = 0x40000000000
movq %rax, 0x18(%rdi)
movl $0xa, 0x20(%rdi)
movl $0x28, %edi
callq 0x7200
movq %rax, %r15
movq %r12, 0x8(%rax)
leaq 0x20433(%rip), %rax     # 0x2b780
movq %rax, (%r15)
movl $0x28, %edi
callq 0x7030
movq %rax, 0x10(%r15)
movq $0x5, 0x20(%r15)
movq $0x0, 0x18(%r15)
movq %r15, 0x10(%r14)
xorl %r13d, %r13d
movq 0x10(%r14), %r12
movl $0x28, %edi
callq 0x7200
movq %rax, %r15
movslq 0x1c(%r14), %rax
leaq (,%rax,4), %rdi
testq %rax, %rax
movl $0x0, %ecx
movq %rcx, 0x8(%r15)
leaq 0x206eb(%rip), %rdx     # 0x2ba90
movq %rdx, (%r15)
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
movq $-0x1, %rax
cmovsq %rax, %rdi
callq 0x7030
movq %rax, 0x10(%r15)
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x58(%rax)
incl %r13d
cmpl 0x20(%r14), %r13d
jl 0xb375
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x40(%rbp)
testl %ebx, %ebx
jle 0xb435
movl -0x40(%rbp), %ecx
cmpq $0x28, %rcx
ja 0xb417
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0xb423
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x98(%rax)
decl %ebx
jne 0xb3ff
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb449
movq %rax, %rbx
movq %r15, %rdi
callq 0x71d0
movq %rbx, %rdi
callq 0x7350
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/tests/./../src/application/application.h
// Function: Trivial::run_()
void run_() {
    size_t SZ = 1000*1000;
    double* vals = new double[SZ];
    double sum = 0;
    for (size_t i = 0; i < SZ; ++i) sum += vals[i] = i;
    Key key("triv",0);
    DistributedDataFrame* df = DistributedDataFrame::fromArray(&key, kv_, SZ, vals);
    assert(df->get_double(0,1) == 1);
    Deserializable* ds = new Deserializable();
    DistributedDataFrame* df2 = dynamic_cast<DistributedDataFrame*>(ds->deserialize(kv_->get(&key)->data, kv_));
    for (size_t i = 0; i < SZ; ++i) sum -= df2->get_double(0,i);
    assert(sum==0);
    delete df; delete df2;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x7a1200, %edi         # imm = 0x7A1200
callq 0x7030
movq %rax, %rbx
xorpd %xmm1, %xmm1
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, (%rbx,%rax,8)
addsd %xmm0, %xmm1
incq %rax
cmpq $0xf4240, %rax          # imm = 0xF4240
jne 0x1c13d
movsd %xmm1, -0x20(%rbp)
leaq 0x4a39(%rip), %rsi      # 0x20b9e
leaq -0x40(%rbp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0xac04
movq 0x10(%r14), %rsi
movl $0xf4240, %edx          # imm = 0xF4240
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1c29e
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1c3da
cmpl $0x1, %eax
jne 0x1c250
movl $0x1, %edi
callq 0x7200
movq %rax, %r15
movq 0x10(%r14), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14a56
movq 0x10(%rax), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0x1ce2e
testq %rax, %rax
je 0x1c1ee
leaq 0xf138(%rip), %rsi      # 0x2b310
leaq 0x10a71(%rip), %rdx     # 0x2cc50
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7230
movq %rax, %r14
jmp 0x1c1f1
xorl %r14d, %r14d
movsd -0x20(%rbp), %xmm1
xorl %r15d, %r15d
movsd %xmm1, -0x20(%rbp)
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1c3da
movsd -0x20(%rbp), %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
subsd %xmm0, %xmm1
incq %r15
cmpq $0xf4240, %r15          # imm = 0xF4240
jne 0x1c1f9
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x1c26f
jp 0x1c26f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x494c(%rip), %rdi      # 0x20ba3
leaq 0x495e(%rip), %rsi      # 0x20bbc
leaq 0x497a(%rip), %rcx      # 0x20bdf
movl $0x2e, %edx
callq 0x7130
leaq 0x4986(%rip), %rdi      # 0x20bfc
leaq 0x493f(%rip), %rsi      # 0x20bbc
leaq 0x495b(%rip), %rcx      # 0x20bdf
movl $0x32, %edx
callq 0x7130
// File: /workspace/github_cpp_makefile_star2_O3/i32ropie[P]n-queen-microservice/./reinas.hpp
// Function: al::lugar(int const&, std::vector<int, std::allocator<int>> const&)
bool lugar(const int &k, const std::vector<int> &x){
        for(int i = 0 ; i < k ; ++i){
            if( x[i] == x[k] || abs(x[i] - x[k]) == abs(i - k))
                return false;
        }
        return true;
    }

// Assembly:
movslq (%rdi), %rcx
testq %rcx, %rcx
jle 0x23da
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rdx
movl (%rdx,%rcx,4), %esi
movl (%rdx), %r9d
cmpl %esi, %r9d
jne 0x23de
xorl %eax, %eax
jmp 0x2421
movb $0x1, %al
jmp 0x2422
movl %ecx, %edi
negl %edi
movl $0x1, %r8d
xorl %eax, %eax
subl %esi, %r9d
movl %r9d, %r10d
negl %r10d
cmovsl %r9d, %r10d
leal (%rdi,%r8), %r9d
decl %r9d
movl %r9d, %r11d
negl %r11d
cmovsl %r9d, %r11d
cmpl %r11d, %r10d
je 0x2421
cmpq %rcx, %r8
setae %al
je 0x2421
movl (%rdx,%r8,4), %r9d
incq %r8
cmpl %esi, %r9d
jne 0x23ea
popq %rbp
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/i32ropie[P]n-queen-microservice/./extra_functions.hpp
// Function: imprimir_tablero(std::vector<int, std::allocator<int>> const&)
void imprimir_tablero(const std::vector<int> &sol){
    for(int i = 0 ; i < sol.size() ; ++i){
        for(int j = 0 ; j < sol.size() ; ++j){
            if(j == sol[i]){
                std::cout << "\e[101m  ";
            }
            else if((i+j)%2==0){
                std::cout << "\e[47m  ";
            }
            else{
                std::cout << "\e[40m  ";
            }
        }
        std::cout << "\e[m" << std::endl;
    }
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rax, %rcx
je 0x2508
movq %rdi, %rbx
xorl %r13d, %r13d
movq 0x3b88(%rip), %r14      # 0x5fd8
leaq 0x1bad(%rip), %r12      # 0x4004
cmpq %rax, %rcx
je 0x24b0
xorl %r15d, %r15d
movl (%rax,%r13,4), %eax
cmpq %rax, %r15
jne 0x2475
movl $0x8, %edx
movq %r14, %rdi
movq %r12, %rsi
jmp 0x2495
leal (%r15,%r13), %eax
movl $0x7, %edx
movq %r14, %rdi
testb $0x1, %al
jne 0x248e
leaq 0x1b81(%rip), %rsi      # 0x400d
jmp 0x2495
leaq 0x1b80(%rip), %rsi      # 0x4015
callq 0x2190
incq %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
ja 0x245f
movl $0x3, %edx
movq %r14, %rdi
leaq 0x1b5e(%rip), %rsi      # 0x401d
callq 0x2190
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r13, %rdx
ja 0x2457
movq 0x3ac9(%rip), %rbx      # 0x5fd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20c0
// File: /workspace/github_cpp_makefile_star2_O3/i32ropie[P]n-queen-microservice/./extra_functions.hpp
// Function: mostrar_soluciones(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
void mostrar_soluciones(const std::vector<std::vector<int>> &soluciones){
    for(int k = 0 ; k < soluciones.size() ; ++k){
        std::cout << "Solución " << k+1 << std::endl;
        std::vector<int> sol = soluciones[k];
        imprimir_tablero(sol);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rdi), %rax
cmpq (%rdi), %rax
je 0x260c
movq %rdi, %rbx
xorl %r14d, %r14d
leaq -0x40(%rbp), %r12
xorl %r13d, %r13d
movl $0xa, %edx
movq 0x3a5d(%rip), %r15      # 0x5fd8
movq %r15, %rdi
leaq 0x1a9c(%rip), %rsi      # 0x4021
callq 0x2190
incq %r13
movq %r15, %rdi
movl %r13d, %esi
callq 0x2210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq (%rbx), %rsi
addq %r14, %rsi
movq %r12, %rdi
callq 0x2e42
movq %r12, %rdi
callq 0x2425
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x25e6
callq 0x2140
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
addq $0x18, %r14
cmpq %r13, %rax
ja 0x256f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x262c
callq 0x2140
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/i32ropie[P]n-queen-microservice/main.cpp
// Function: main
int main(int argc, char *argv[]) {
    int n = atoi(argv[1]);
    al::Reinas r(n);
    r.resolver_backtracking();
    std::cout << exportar_soluciones(r.get_soluciones());
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movq 0x8(%rsi), %rdi
callq 0x21e0
xorl %ecx, %ecx
leaq -0x70(%rbp), %rdi
movq %rcx, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movl %eax, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
callq 0x2ec2
leaq -0x20(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3446
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2634
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq 0x3203(%rip), %rdi      # 0x5fd8
callq 0x2190
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2dec
callq 0x2140
leaq -0x20(%rbp), %rdi
callq 0x2fe4
leaq -0x70(%rbp), %rdi
callq 0x2fe4
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e21
callq 0x2140
jmp 0x2e21
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x2fe4
jmp 0x2e31
jmp 0x2e2e
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2fe4
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/i32ropie[P]n-queen-microservice/./reinas.hpp
// Function: al::Reinas::resolver_backtracking()
void resolver_backtracking() {
            if( _reinas <= 3 )
                return;
            _soluciones.clear();
            std::vector<int> aux(_reinas, -1);
            int k = 0;
            while( k >= 0 ){
                do{
                    aux[k]++;
                }while( aux[k] < _reinas && !lugar(k, aux));
                if( aux[k] < _reinas ){
                    if( k == _reinas-1 ){
                        _soluciones.push_back(aux);
                    }
                    else{
                        ++k;
                        aux[k] = -1;
                    }
                }
                else{
                    --k;
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x4, 0x18(%rdi)
jl 0x2fbf
movq %rdi, %rbx
callq 0x3138
movslq 0x18(%rbx), %rsi
leaq -0x20(%rbp), %rdx
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
leaq -0x38(%rbp), %r14
leaq -0x19(%rbp), %rcx
movq %r14, %rdi
callq 0x317a
xorl %r15d, %r15d
movl %r15d, %eax
movq -0x38(%rbp), %rcx
movl (%rcx,%rax,4), %edx
incl %edx
movl %edx, (%rcx,%rax,4)
movl 0x18(%rbx), %esi
cmpl %esi, %edx
jge 0x2f82
movl %r15d, %edi
negl %edi
testl %r15d, %r15d
je 0x2f90
movl (%rcx), %r8d
subl %edx, %r8d
je 0x2f76
movl %r8d, %r9d
negl %r9d
cmovsl %r8d, %r9d
cmpl %r15d, %r9d
je 0x2f76
movl $0x1, %r9d
movq %r9, %r8
cmpq %r9, %rax
je 0x2f71
movl (%rcx,%r8,4), %r9d
subl %edx, %r9d
je 0x2f71
movl %r9d, %r10d
negl %r10d
cmovsl %r9d, %r10d
leal (%rdi,%r8), %r9d
movl %r9d, %r11d
negl %r11d
cmovsl %r9d, %r11d
leaq 0x1(%r8), %r9
cmpl %r11d, %r10d
jne 0x2f3f
cmpq %rax, %r8
jae 0x2f90
incl %edx
movl %edx, (%rcx,%rax,4)
movl 0x18(%rbx), %esi
cmpl %esi, %edx
jl 0x2f1d
decl %r15d
testl %r15d, %r15d
jns 0x2f02
jmp 0x2fb1
decl %esi
cmpl %esi, %r15d
jne 0x2fa4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3202
jmp 0x2f85
incl %r15d
movl $0xffffffff, 0x4(%rcx,%rax,4) # imm = 0xFFFFFFFF
jmp 0x2f85
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x2fbf
callq 0x2140
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x2fdb
callq 0x2140
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/test/src/findSSRs.cpp
// Function: fillSSRSetFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
void fillSSRSetFromFile(const string &fn, set<string>* ssrs)
{
	ifstream fd;
	fd.open(fn.c_str());

	string line;
	getline(fd, line); // skip past the header line
	while(getline(fd, line))
	{
		ssrs->insert(line);
	}

	fd.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x4360
movq (%r15), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x41e0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x20(%rsp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x42e0
movsbl %al, %edx
leaq 0x20(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x4590
movq %rsp, %r15
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x42e0
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4590
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x6bb2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6fd0
jmp 0x6b73
leaq 0x20(%rsp), %rdi
callq 0x40a0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6bd2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4310
leaq 0x20(%rsp), %rdi
callq 0x40d0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x6c0b
jmp 0x6bf2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6c0b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4310
leaq 0x20(%rsp), %rdi
callq 0x40d0
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/ridgelab[P]Kmer-SSR/test/src/findSSRs.cpp
// Function: actualOutputMatchedExpected(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool actualOutputMatchedExpected(const string &actual_fn, const string &expected_fn)
{
	bool ret_val = true;
	
	set<string>* actual = new set<string>();
	set<string>* expected = new set<string>();
	
	fillSSRSetFromFile(actual_fn, actual);
	fillSSRSetFromFile(expected_fn, expected);

	if (actual->size() != expected->size())
	{
		ret_val = false;
	}
	else
	{
		set<string>::iterator a_itr = actual->begin();
		set<string>::iterator e_itr = expected->begin();
		while (e_itr != expected->end() && a_itr != actual->end()) // expected.size() == actual.size()
		{
			if (*e_itr != *a_itr)
			{
				ret_val = false;
				break;
			}

			++e_itr;
			++a_itr;
		}
	}

	delete actual;
	delete expected;

	return ret_val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq %rdi, %r13
movl $0x30, %edi
callq 0x4300
movq %rax, %rbx
leaq 0x8(%rax), %rbp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rbp, 0x18(%rax)
movq %rbp, 0x20(%rax)
xorl %r12d, %r12d
movq %r12, 0x28(%rax)
movl $0x30, %edi
callq 0x4300
movq %rax, %r14
leaq 0x8(%rax), %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %r15, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %r12, 0x28(%rax)
movq %r13, %rdi
movq %rbx, %rsi
callq 0x6afe
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x6afe
movq 0x28(%rbx), %rax
cmpq 0x28(%r14), %rax
jne 0x6d06
movq 0x18(%rbx), %r12
movq 0x18(%r14), %r13
cmpq %r15, %r13
setne %al
cmpq %rbp, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x6cfe
movq 0x28(%r13), %rdx
cmpq 0x28(%r12), %rdx
jne 0x6d03
testq %rdx, %rdx
je 0x6cde
movq 0x20(%r12), %rsi
movq 0x20(%r13), %rdi
callq 0x4320
testl %eax, %eax
jne 0x6d03
movq %r13, %rdi
callq 0x4380
movq %rax, %r13
movq %r12, %rdi
callq 0x4380
cmpq %r15, %r13
je 0x6cfe
movq %rax, %r12
cmpq %rbp, %rax
jne 0x6cbc
movb $0x1, %r12b
jmp 0x6d06
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x6d92
movl $0x30, %esi
movq %rbx, %rdi
callq 0x4310
movq %r14, %rdi
callq 0x6d92
movl $0x30, %esi
movq %r14, %rdi
callq 0x4310
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/eryxcc[P]lois/tests/../include/loisextra.h
// Function: lois::lsetof<lois::lpair<lois::elem, lois::elem>> lois::operator|<lois::lpair<lois::elem, lois::elem>>(lois::lsetof<lois::lpair<lois::elem, lois::elem>> const&, lois::lsetof<lois::lpair<lois::elem, lois::elem>> const&)
lsetof<T> operator | (const lsetof<T>& x, const lsetof<T>& y) { 
  lsetof<T> xy;
  for(const T& e: x) xy += e;
  for(const T& e: y) xy += e;
  return xy;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x8, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x8(%rbx)
leaq 0x3a4c6(%rip), %rsi     # 0x54358
movq (%rsi), %rax
movq %rax, (%rbx)
addq $0x8, %rsi
callq 0x100a2
movq %rsp, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1d982
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
movl $0x77359400, %edx       # imm = 0x77359400
callq 0x1d982
movq %rsp, %r15
movslq 0x8(%rsp), %rax
testq %rax, %rax
js 0x19eea
movq (%rsp), %rcx
movq 0x18(%rcx), %rdx
subq 0x10(%rcx), %rdx
sarq $0x4, %rdx
cmpq %rax, %rdx
jbe 0x19eea
cmpl 0x38(%rsp), %eax
jne 0x19f0a
jmp 0x19f2d
movslq 0x38(%rsp), %rax
testq %rax, %rax
js 0x19f2d
movq 0x30(%rsp), %rcx
movq 0x18(%rcx), %rdx
subq 0x10(%rcx), %rdx
sarq $0x4, %rdx
cmpq %rax, %rdx
jbe 0x19f2d
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a4b6
movq %r15, %rdi
callq 0x1e926
incl 0x8(%rsp)
movq %r15, %rdi
callq 0x1d9ce
jmp 0x19ec3
leaq 0x30(%rsp), %rdi
callq 0x1d952
movq %rsp, %rdi
callq 0x1d952
movq %rsp, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1d982
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movl $0x77359400, %edx       # imm = 0x77359400
callq 0x1d982
movq %rsp, %r14
movslq 0x8(%rsp), %rax
testq %rax, %rax
js 0x19f88
movq (%rsp), %rcx
movq 0x18(%rcx), %rdx
subq 0x10(%rcx), %rdx
sarq $0x4, %rdx
cmpq %rax, %rdx
jbe 0x19f88
cmpl 0x38(%rsp), %eax
jne 0x19fa8
jmp 0x19fcb
movslq 0x38(%rsp), %rax
testq %rax, %rax
js 0x19fcb
movq 0x30(%rsp), %rcx
movq 0x18(%rcx), %rdx
subq 0x10(%rcx), %rdx
sarq $0x4, %rdx
cmpq %rax, %rdx
jbe 0x19fcb
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a4b6
movq %r14, %rdi
callq 0x1e926
incl 0x8(%rsp)
movq %r14, %rdi
callq 0x1d9ce
jmp 0x19f61
leaq 0x30(%rsp), %rdi
callq 0x1d952
movq %rsp, %rdi
callq 0x1d952
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x19fee
jmp 0x19ff3
movq %rax, %r14
jmp 0x1a00b
movq %rax, %r14
jmp 0x1a013
jmp 0x19ffe
jmp 0x19ffe
jmp 0x19ffe
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x1d952
movq %rsp, %rdi
callq 0x1d952
movq %rbx, %rdi
callq 0x1a32e
movq %r14, %rdi
callq 0x7430
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_testgen.cpp
// Function: main
int main(int argc, char* argv[])
{
   if (argc != 2)
   {
      printf("usage: exprtk_testgen <file name>\n");
      return 1;
   }

   const std::string file_name = argv[1];
   test_gen<double>(file_name);

   return 0;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpl $0x2, %edi
jne 0x119343
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x119420
movq %rbx, %rdi
callq 0x11945d
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11933f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1160c0
xorl %eax, %eax
jmp 0x119354
leaq 0x195103(%rip), %rdi    # 0x2ae44d
callq 0x116500
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x119378
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1160c0
movq %rbx, %rdi
callq 0x116310
// File: /workspace/github_cpp_makefile_star2_O3/EnderGed[P]fast-random-walk/Graph.cpp
// Function: Graph::doWalk(unsigned int, unsigned int, FastPRNG&, char*) const
size_t Graph::doWalk(uint node, uint32_t walk_len, FastPRNG & prng, char * const out) const
{
	// Write start node to output string
	char * outPos = out;

	{
		unsigned const wrote = writeInt(outPos, node);
		outPos += wrote;
	}

	while(--walk_len)
	{
		// Determine the number of outgoing transitions (from the current node)
		uint const outgoingTransitions = getNumTransitions(node);
		if(!outgoingTransitions)
		{
			fprintf(stderr, "Node %d has no outgoing transitions\n", node);
			break;
		}

		// Choose a successor node
		node = getNode(node, prng.uniformInRange<uint>(outgoingTransitions - 1));

		// Write node number to output
		{
			*(outPos++) = ',';
			unsigned const wrote = writeInt(outPos, node);
			outPos += wrote;
		}
	}

	*outPos = '\0';

	return outPos - out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r13d
movq %rdi, %r12
movq %r8, %rdi
callq 0x3ab5
movl %eax, %r14d
movq %rbx, (%rsp)
addq %rbx, %r14
decl %ebp
je 0x2518
cmpl %r13d, 0x8(%r12)
jbe 0x24fd
movq 0x10(%r12), %rax
movl %r13d, %ebx
movl 0x8(%rax,%rbx,8), %esi
subl (%rax,%rbx,8), %esi
je 0x24fd
decl %esi
movq %r15, %rdi
callq 0x3008
movq 0x10(%r12), %rcx
movq (%rcx,%rbx,8), %rcx
shlq $0x2, %rcx
addq 0x18(%r12), %rcx
movl %eax, %eax
movl (%rcx,%rax,4), %r13d
leaq 0x1(%r14), %rdi
movb $0x2c, (%r14)
movl %r13d, %esi
callq 0x3ab5
movl %eax, %eax
addq %rax, %r14
incq %r14
jmp 0x24a5
movq 0x6adc(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
leaq 0x3b52(%rip), %rsi      # 0x6060
movl %r13d, %edx
xorl %eax, %eax
callq 0x2220
movb $0x0, (%r14)
subq (%rsp), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/EnderGed[P]fast-random-walk/Graph.cpp
// Function: Graph::toString[abi:cxx11]() const
std::string Graph::toString() const
{
	unsigned const maxDigits = hasDigits(getNumNodes() - 1);

	char asString[maxDigits];

	std::string res;
	res.reserve((maxDigits * 2 + 5) * getNumTransitions());

	for(uint node = 0; node < numNodes; ++node)
	{
		uint const numTrans = getNumTransitions(node);

		for(uint trans = 0; trans < numTrans; ++trans)
		{
			// Add source node
			unsigned len = writeInt(asString, node);
			res.append(asString, len);
			// Add " ->"
			res.append(" -> ", 4);
			// Add destination node
			len = writeInt(asString, getNode(node, trans));
			res.append(asString, len);
			res.append(1, '\n');
		}
	}

	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
decl %eax
cvtsi2sd %rax, %xmm0
callq 0x20c0
callq 0x2060
cvttsd2si %xmm0, %rax
movl %eax, %ecx
movq %rsp, %r15
addq $0xf, %rcx
andq $-0x10, %rcx
subq %rcx, %r15
movq %r15, %rsp
leaq 0x10(%rbx), %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leal 0x5(,%rax,2), %esi
movq 0x10(%r14), %rax
movl 0x8(%r14), %ecx
imulq (%rax,%rcx,8), %rsi
movq %rbx, %rdi
callq 0x2260
movl 0x8(%r14), %eax
testl %eax, %eax
je 0x269e
xorl %r12d, %r12d
movq 0x10(%r14), %rdx
movq 0x8(%rdx,%r12,8), %rcx
subq (%rdx,%r12,8), %rcx
testl %ecx, %ecx
je 0x2690
movl %ecx, %eax
movq %rax, -0x38(%rbp)
xorl %r13d, %r13d
movq %r15, %rdi
movl %r12d, %esi
callq 0x3ab5
movl %eax, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2050
movl $0x4, %edx
movq %rbx, %rdi
leaq 0x3a49(%rip), %rsi      # 0x6085
callq 0x2050
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
shlq $0x2, %rax
addq 0x18(%r14), %rax
movl (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x3ab5
movl %eax, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2050
movq 0x8(%rbx), %rsi
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
movl $0xa, %r8d
callq 0x22b0
incq %r13
cmpq %r13, -0x38(%rbp)
jne 0x2615
movl 0x8(%r14), %eax
incq %r12
movl %eax, %ecx
cmpq %rcx, %r12
jb 0x25f7
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26b2
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x26c3
callq 0x2160
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O3/EnderGed[P]fast-random-walk/Graph.cpp
// Function: Graph::readInt(char const*, char const*, unsigned int&)
uint Graph::readInt(char const * const start, char const * const end, unsigned & readLen)
{
	char const * pos = start;
	read_t result = 0;

	// Skip space characters
	while(pos < end && *pos > 0 && *pos <= ' ') ++pos;

	// Ensure that the first non-space character is a digit
	if(pos >= end || *pos < '0' || *pos > '9') {fprintf(stderr, "Not a number: %c\n", *pos); exit(1);}

	// Read digit by digit until a non-digit occurs
	for(; pos < end; ++pos)
	{
		char const c = *pos;
		if(c < '0' || c > '9') break;

		result *= 10;
		result += c - '0';

		if(result > ((uint)-1)) printError("Specified integer type is too small to hold this number.");
	}

	readLen = pos - start;

	// Return the number
	return (uint) result;
}

// Assembly:
pushq %rax
cmpq %rsi, %rdi
jae 0x2710
movq %rdi, %rcx
movb (%rcx), %al
leal -0x1(%rax), %r8d
cmpb $0x1f, %r8b
ja 0x2738
incq %rcx
cmpq %rsi, %rcx
jne 0x26f9
movq %rsi, %rdi
movq 0x68c9(%rip), %rax      # 0x8fe0
movq (%rax), %rax
movsbl (%rdi), %edx
leaq 0x3966(%rip), %rsi      # 0x608a
movq %rax, %rdi
xorl %eax, %eax
callq 0x2220
movl $0x1, %edi
callq 0x21e0
addb $-0x3a, %al
cmpb $-0xa, %al
jb 0x2787
xorl %eax, %eax
cmpq %rsi, %rcx
jae 0x2775
xorl %eax, %eax
movzbl (%rcx), %r8d
leal -0x3a(%r8), %r9d
cmpb $-0xa, %r9b
jb 0x2775
leaq (%rax,%rax,4), %rax
andl $0xf, %r8d
leaq (%r8,%rax,2), %rax
movq %rax, %r8
shrq $0x20, %r8
jne 0x277b
incq %rcx
cmpq %rsi, %rcx
jb 0x2747
movq %rsi, %rcx
subl %edi, %ecx
movl %ecx, (%rdx)
popq %rcx
retq
leaq 0x391a(%rip), %rdi      # 0x609c
callq 0x390d
movq %rcx, %rdi
jmp 0x2710
// File: /workspace/github_cpp_makefile_star2_O3/EnderGed[P]fast-random-walk/./FastPRNG.hpp
// Function: unsigned int FastPRNG::uniformInRange<unsigned int>(unsigned int)
T FastPRNG::uniformInRange(T max)
{
	// If PRNG 2 was used 256 times ...
	if(++prngResetCounter > 0xffff)
	{
		prngResetCounter = 0;

		// Re-Seed PRNG 2 with output of PRNG 1
		g2.seed(g1());
	}

	return std::uniform_int_distribution<T>(0, max)(g2);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x1390(%rdi), %eax
incl %eax
movl %eax, 0x1390(%rdi)
cmpl $0x10000, %eax          # imm = 0x10000
jb 0x3073
movl $0x0, 0x1390(%rbx)
movq %rbx, %rdi
callq 0x3156
movq %rax, %rcx
movabsq $0x200000005, %rdx      # imm = 0x200000005
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1e, %rax
movq %rax, %rdx
shlq $0x1f, %rdx
subq %rdx, %rax
leaq (%rcx,%rax), %rdx
cmpq $0x1, %rdx
adcq %rcx, %rax
movq %rax, 0x1388(%rbx)
movq %rsp, %rdi
movl $0x0, (%rdi)
movl %ebp, 0x4(%rdi)
addq $0x1388, %rbx           # imm = 0x1388
movq %rbx, %rsi
movq %rdi, %rdx
callq 0x32c2
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: readFile[abi:cxx11](char const*)
std::string readFile(char const * const fileName)
{
	// Open file
	FILE * const file = fopen(fileName, "r");
	if(!file) printError("File could not be opened for reading");

	// Determine file size
	fseek(file, 0L, SEEK_END);
	size_t const fileSize = ftell(file);
	fseek(file, 0L, SEEK_SET);

	// Create buffer array
	char * const result = (char *) malloc(fileSize * sizeof(*result) + 1);

	// Read whole file
	size_t const read = fread(result, 1, fileSize, file);
	result[read] = '\n';

	// Error if file size and number of bytes read are different
	if(fileSize != read)
	{
		fprintf(stderr, "File size: %lu, but read: %lu\n", (unsigned long) fileSize, (unsigned long) read);
		exit(1);
	}

	// Close file
	fclose(file);

	std::string const res = std::string(result, fileSize);
	
	free(result);
	
	return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x2854(%rip), %rsi      # 0x619c
movq %rax, %rdi
callq 0x21c0
testq %rax, %rax
je 0x39e2
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2190
movq %r14, %rdi
callq 0x2030
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2190
leaq 0x1(%r15), %rdi
callq 0x21f0
movq %rax, %r12
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2240
movb $0xa, (%r12,%rax)
cmpq %rax, %r15
jne 0x39ee
movq %r14, %rdi
callq 0x2170
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %r12, %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x409e
movq %r12, %rdi
callq 0x21d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x270f(%rip), %rdi      # 0x60f8
callq 0x390d
movq %r15, %rdi
movq %rax, %rsi
callq 0x22f1
// File: /workspace/github_cpp_makefile_star2_O3/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: writeFile(char const*, char const*)
void writeFile(char const * const fileName, char const * const content)
{
	size_t const len = strlen(content);

	// Open file
	FILE * const file = fopen(fileName, "w");
	if(!file) printError("File could not be opened for writing");

	// Write to file
	size_t const w = fwrite(content, sizeof(*content), len, file);
	if(w < len) printError("Could not write full file content");

	// Close file
	fclose(file);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x20a0
movq %rax, %r14
leaq 0x2726(%rip), %rsi      # 0x613c
movq %r15, %rdi
callq 0x21c0
testq %rax, %rax
je 0x3a4b
movq %rax, %r15
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0x22c0
cmpq %r14, %rax
jb 0x3a57
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2170
leaq 0x26ec(%rip), %rdi      # 0x613e
callq 0x390d
leaq 0x2705(%rip), %rdi      # 0x6163
callq 0x390d
// File: /workspace/github_cpp_makefile_star2_O3/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: toInt(char const*)
uint32_t toInt(char const * str)
{
	register uint64_t res = 0;

	// For every character in str ...
	for(; *str != '\0'; ++str)
	{
		// Check if character is a number
		if(*str < '0' || *str > '9') printError("Argument is not a number");

		// Adapt result according to character
		res *= 10;
		res += *str - '0';

		// Check for integer overflow
		if(res > 0xffffffff) printError("Number in argument is too large");
	}

	return (uint32_t) res;
}

// Assembly:
pushq %rax
movb (%rdi), %cl
testb %cl, %cl
je 0x3a99
incq %rdi
xorl %eax, %eax
leal -0x3a(%rcx), %edx
cmpb $-0xb, %dl
jbe 0x3a9d
leaq (%rax,%rax,4), %rax
addb $-0x30, %cl
movzbl %cl, %ecx
leaq (%rcx,%rax,2), %rax
movq %rax, %rcx
shrq $0x20, %rcx
jne 0x3aa9
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x3a6f
jmp 0x3a9b
xorl %eax, %eax
popq %rcx
retq
leaq 0x26e1(%rip), %rdi      # 0x6185
callq 0x390d
leaq 0x26ee(%rip), %rdi      # 0x619e
callq 0x390d
// File: /workspace/github_cpp_makefile_star2_O3/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: writeInt(char*, unsigned int)
unsigned writeInt(char * const target, uint number)
{
	register char * pos = target;

	// For every decimal digit of number (at least once)
	do
	{
		// Add digicimal digit to output
		*pos++ = ((char)(number % 10)) + '0';
		// Remove decimal digit from number
		number /= 10;
	}while(number);

	// Reverse output
	std::reverse(target, pos);

	// Return number of written characters
	return pos - target;
}

// Assembly:
leaq -0x1(%rdi), %rcx
xorl %eax, %eax
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movl %esi, %r8d
imulq %rdx, %r8
shrq $0x23, %r8
leal (%r8,%r8), %r9d
leal (%r9,%r9,4), %r9d
movl %esi, %r10d
subl %r9d, %r10d
orb $0x30, %r10b
movb %r10b, 0x1(%rcx)
incq %rcx
incl %eax
cmpl $0x9, %esi
movl %r8d, %esi
ja 0x3ac0
cmpq %rdi, %rcx
jbe 0x3b11
incq %rdi
movb -0x1(%rdi), %dl
movb (%rcx), %sil
movb %sil, -0x1(%rdi)
movb %dl, (%rcx)
decq %rcx
leaq 0x1(%rdi), %rdx
cmpq %rcx, %rdi
movq %rdx, %rdi
jb 0x3af6
retq
// File: /workspace/github_cpp_makefile_star2_O3/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: prepareAdjList(unsigned int const*, unsigned long, unsigned int)
read_t * prepareAdjList(uint const * const list, size_t const size, uint maxVal)
{
	// Allocate adjacency list
	read_t * const adj = (read_t*) calloc((maxVal + 2), sizeof(*adj));
	if(!adj) printError("Memory allocation failed");
	read_t * const counts = adj + 1;

	// Count occurences of each index
	for(register uint const * pos = list; pos < (list + size); ++pos) ++(counts[*pos]);

	// Convert occurency counts to real adjacency list
	read_t * const adjEnd = adj + maxVal + 1;
	adj[0] = 0;
	for(register read_t * adjPos = adj; adjPos < adjEnd; ++adjPos) adjPos[1] += adjPos[0];

	// Return adjacency list
	return adj;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leal 0x2(%rbx), %edi
movl $0x8, %esi
callq 0x20f0
testq %rax, %rax
je 0x3d26
testq %r15, %r15
jle 0x3d00
leaq (%r14,%r15,4), %rcx
movl (%r14), %edx
incq 0x8(%rax,%rdx,8)
addq $0x4, %r14
cmpq %rcx, %r14
jb 0x3cef
movl %ebx, %ecx
leaq (%rax,%rcx,8), %rcx
movq %rax, %rdx
addq $-0x8, %rdx
xorl %esi, %esi
addq 0x10(%rdx), %rsi
movq %rsi, 0x10(%rdx)
addq $0x8, %rdx
cmpq %rcx, %rdx
jb 0x3d0f
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2491(%rip), %rdi      # 0x61be
callq 0x390d
// File: /workspace/github_cpp_makefile_star2_O3/EnderGed[P]fast-random-walk/HelperFunctions.cpp
// Function: countSort(unsigned int*, unsigned long)
void countSort(uint * const list, size_t const size)
{
	// Determine maximum list value
	uint const maxVal = maxValue(list, size);

	// Allocate counter list
	read_t * const counts = (read_t*) calloc((maxVal + 1), sizeof(*counts));
	if(!counts) printError("Memory allocation failed");

	// Count occurences of each index
	for(uint const * pos = list; pos < (list + size); ++pos) ++(counts[*pos]);

	// Write counted elements back to list
	register uint val = 0;
	for(register read_t pos = 0; pos < size; ++pos)
	{
		// Go to next count greater zero
		while(!counts[val]) ++val;
		
		// Add value to list
		list[pos] = val;
		--counts[val];
	}
	
	free(counts);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
jle 0x3d85
leaq (%r14,%rbx,4), %r15
xorl %edi, %edi
movq %r14, %rax
movl (%rax), %ecx
cmpl %edi, %ecx
cmoval %ecx, %edi
addq $0x4, %rax
cmpq %r15, %rax
jb 0x3d4b
incl %edi
movl $0x8, %esi
callq 0x20f0
testq %rax, %rax
je 0x3dd1
testq %rbx, %rbx
jle 0x3d99
movq %r14, %rcx
movl (%rcx), %edx
incq (%rax,%rdx,8)
addq $0x4, %rcx
cmpq %r15, %rcx
jb 0x3d74
jmp 0x3d99
movl $0x1, %edi
movl $0x8, %esi
callq 0x20f0
testq %rax, %rax
je 0x3dd1
testq %rbx, %rbx
je 0x3dc4
xorl %ecx, %ecx
xorl %edx, %edx
movl %edx, %esi
movq (%rax,%rsi,8), %rdi
incl %edx
testq %rdi, %rdi
je 0x3da2
decl %edx
movl %edx, (%r14,%rcx,4)
decq %rdi
movq %rdi, (%rax,%rsi,8)
incq %rcx
cmpq %rbx, %rcx
jne 0x3da2
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x21d0
leaq 0x23e6(%rip), %rdi      # 0x61be
callq 0x390d