LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
pushq $0x1
popq %rdi
callq 0x7220
movq %rax, %rbx
callq 0x74cc
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, %r12
movl $0x118, %edi            # imm = 0x118
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xc018
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r13
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xa064
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0xa064
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x8aac
movq %rbx, %rdi
callq 0xf396
leaq 0x11922(%rip), %rsi     # 0x1a3d5
movq %rbx, %rdi
callq 0xf3ae
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7280
movq %rax, %rbx
movq %r12, %r15
jmp 0x8ae7
jmp 0x8ae4
movq %rax, %rbx
movq %r15, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testIntDistributedArrays()
void testIntDistributedArrays() {
    Sys* system = new Sys();
    NetworkIP network;
    KVStore* kvs1 = new KVStore(1, 0, &network);
    IntDistributedArray* ida = new IntDistributedArray(kvs1);
    for(int i = 0; i < 10; i++) {
        //std::cout << "here\n";
        ida->pushBack(i);
    }
    char* serialized = ida->serialize();
    IntDistributedArray* ida2 = new IntDistributedArray(serialized, kvs1);
    //std::cout << "here\n";
    system->t_true(ida->equals(ida2)); //problem child
    String* s = new String(serialized);
    String* s2 = new String(ida2->serialize());
    system->t_true(s2->equals(s));
    system->OK("Passed intDistributedArray");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
pushq $0x1
popq %rdi
callq 0x7220
andq $0x0, -0x68(%rbp)
leaq 0x1da3c(%rip), %rcx     # 0x26558
movq %rcx, -0x70(%rbp)
movq $0x1, -0x58(%rbp)
andq $0x0, -0x50(%rbp)
movq %rax, %rbx
andq $0x0, -0x30(%rbp)
movl $0x118, %edi            # imm = 0x118
callq 0x7220
movq %rax, %r14
pushq $0x1
popq %rsi
leaq -0x70(%rbp), %rcx
movq %rax, %rdi
xorl %edx, %edx
callq 0x9dd4
pushq $0x70
popq %rdi
callq 0x7220
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0xc180
xorl %r15d, %r15d
cmpl $0xa, %r15d
je 0x8b82
movq %r12, %rdi
movl %r15d, %esi
callq 0xc22c
incl %r15d
jmp 0x8b6c
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movq %rax, %r13
pushq $0x70
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0xc298
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x8bc1
movq %rbx, %rdi
callq 0xf396
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
callq 0xa064
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0xa064
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x8c0f
movq %rbx, %rdi
callq 0xf396
leaq 0x117dc(%rip), %rsi     # 0x1a3f2
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x7280
leaq -0x70(%rbp), %rdi
callq 0xa00a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8c50
jmp 0x8c6b
movq %rax, %rbx
movq %r15, %rdi
jmp 0x8c60
jmp 0x8c6b
jmp 0x8c5a
jmp 0x8c6b
movq %rax, %rbx
movq %r14, %rdi
jmp 0x8c60
jmp 0x8c6b
movq %rax, %rbx
movq %r12, %rdi
callq 0x71f0
jmp 0x8c6e
jmp 0x8c6b
jmp 0x8c6b
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0xa00a
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testStringDistributedArrays()
void testStringDistributedArrays() {
    Sys* system = new Sys();
    NetworkIP network;
    KVStore* kvs1 = new KVStore(1, 0, &network);
    StringDistributedArray* sda = new StringDistributedArray(kvs1);
    StringArray* sa = genStringArray();
    for(int i = 0; i < 10; i++) {
        sda->pushBack(sa->get(i));
    }
    char* serialized = sda->serialize();
    StringDistributedArray* sda2 = new StringDistributedArray(serialized, kvs1);
    String* s = new String(serialized);
    String* s2 = new String(sda2->serialize());
    system->t_true(s2->equals(s));
    for(int i = 0; i < 10; i++) {
        system->t_true(sda->get(i)->equals(sa->get(i)));
    }
    system->OK("Passed StringDistributedArray");
    delete sa;
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
pushq $0x1
popq %rdi
callq 0x7220
andq $0x0, -0x70(%rbp)
leaq 0x1d8b4(%rip), %rcx     # 0x26558
movq %rcx, -0x78(%rbp)
movq $0x1, -0x60(%rbp)
andq $0x0, -0x58(%rbp)
movq %rax, %rbx
andq $0x0, -0x38(%rbp)
movl $0x118, %edi            # imm = 0x118
callq 0x7220
movq %rax, %r15
pushq $0x1
popq %rsi
leaq -0x78(%rbp), %rcx
movq %rax, %rdi
xorl %edx, %edx
callq 0x9dd4
pushq $0x70
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xc548
movq %r15, -0x30(%rbp)
callq 0x7615
movq %rax, %r15
xorl %r12d, %r12d
cmpq $0xa, %r12
je 0x8d21
movq %r15, %rdi
movq %r12, %rsi
callq 0xc660
movq %r14, %rdi
movq %rax, %rsi
callq 0xc5f4
incq %r12
jmp 0x8d00
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, %r12
pushq $0x70
popq %rdi
callq 0x7220
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq -0x30(%rbp), %rdx
callq 0xc692
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, -0x30(%rbp)
movq %rax, %rdi
movq %r12, %rsi
callq 0xa064
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
movq (%r13), %rax
movq %r13, %rdi
callq *0x38(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0xa064
movq (%r12), %rax
movq %r12, %rdi
movq -0x30(%rbp), %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x8d98
movq %rbx, %rdi
callq 0xf396
xorl %r12d, %r12d
cmpq $0xa, %r12
je 0x8dd8
movq %r14, %rdi
movq %r12, %rsi
callq 0xc942
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0xc660
movq (%r13), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
testb %al, %al
jne 0x8dd3
movq %rbx, %rdi
callq 0xf396
incq %r12
jmp 0x8d9b
leaq 0x1162e(%rip), %rsi     # 0x1a40d
movq %rbx, %rdi
callq 0xf3ae
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7280
leaq -0x78(%rbp), %rdi
callq 0xa00a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0x8e43
jmp 0x8e4e
movq %rax, %rbx
movq %r13, %rdi
jmp 0x8e43
jmp 0x8e4e
jmp 0x8e4e
jmp 0x8e4e
movq %rax, %rbx
movq %r14, %rdi
jmp 0x8e43
jmp 0x8e4e
movq %rax, %rbx
movq %r15, %rdi
jmp 0x8e43
jmp 0x8e4e
movq %rax, %rbx
movq %r12, %rdi
callq 0x71f0
jmp 0x8e51
jmp 0x8e4e
jmp 0x8e4e
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0xa00a
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testFloatDistributedArrays()
void testFloatDistributedArrays() {
    Sys* system = new Sys();
    NetworkIP network;
    KVStore* kvs1 = new KVStore(1, 0, &network);
    FloatDistributedArray* fda = new FloatDistributedArray(kvs1);
    for(int i = 0; i < 40; i++) {
        fda->pushBack(i);
    }
    char* serialized = fda->serialize();   
    FloatDistributedArray* fda2 = new FloatDistributedArray(serialized, kvs1);
    String* s = new String(serialized);
    char* serial = fda2->serialize();
    String* s2 = new String(fda2->serialize());
    system->t_true(s2->equals(s));
    for(int i = 0; i < 10; i++) {
        system->t_true(fda->get(i) == i);
    }
    system->OK("Passed FloatDistributedArray");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
pushq $0x1
popq %rdi
callq 0x7220
andq $0x0, -0x68(%rbp)
leaq 0x1d6d1(%rip), %rcx     # 0x26558
movq %rcx, -0x70(%rbp)
movq $0x1, -0x58(%rbp)
andq $0x0, -0x50(%rbp)
movq %rax, %rbx
andq $0x0, -0x30(%rbp)
movl $0x118, %edi            # imm = 0x118
callq 0x7220
movq %rax, %r15
pushq $0x1
popq %rsi
leaq -0x70(%rbp), %rcx
movq %rax, %rdi
xorl %edx, %edx
callq 0x9dd4
pushq $0x70
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xca10
xorl %r12d, %r12d
cmpl $0x28, %r12d
je 0x8eef
cvtsi2ss %r12d, %xmm0
movq %r14, %rdi
callq 0xcabc
incl %r12d
jmp 0x8ed7
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, %r13
pushq $0x70
popq %rdi
callq 0x7220
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xcb32
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
callq 0xa064
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r13
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movq %r13, %rdi
movq %rax, %rsi
callq 0xa064
movq (%r13), %rax
movq %r13, %rdi
movq %r15, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x8f6d
movq %rbx, %rdi
callq 0xf396
xorl %r15d, %r15d
cmpq $0xa, %r15
je 0x8f9a
movq %r14, %rdi
movq %r15, %rsi
callq 0xcde2
cvtsi2ss %r15d, %xmm1
ucomiss %xmm1, %xmm0
jne 0x8f8d
jnp 0x8f95
movq %rbx, %rdi
callq 0xf396
incq %r15
jmp 0x8f70
leaq 0x1148a(%rip), %rsi     # 0x1a42b
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x7280
leaq -0x70(%rbp), %rdi
callq 0xa00a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9000
jmp 0x8fe5
jmp 0x9000
movq %rax, %rbx
movq %r12, %rdi
jmp 0x8ff5
jmp 0x9000
jmp 0x9000
movq %rax, %rbx
movq %r14, %rdi
jmp 0x8ff5
jmp 0x9000
movq %rax, %rbx
movq %r15, %rdi
jmp 0x8ff5
jmp 0x9000
movq %rax, %rbx
movq %r13, %rdi
callq 0x71f0
jmp 0x9003
jmp 0x9000
jmp 0x9000
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0xa00a
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testDistributedIntColumn()
void testDistributedIntColumn() {
    Sys* system = new Sys();
    NetworkIP network;
    KVStore* kvs1 = new KVStore(1, 0, &network);
    DistributedIntColumn* dfc = new DistributedIntColumn(kvs1);
    for(int i = 0; i < 40; i++) {
        dfc->push_back(i);
    }
    char* serialized = dfc->serialize();
    // std::cout << "here\n";
    // std::cout << serialized << "\n";   
    DistributedIntColumn* fda2 = new DistributedIntColumn(serialized, kvs1);
    String* s = new String(serialized);
    char* serial = fda2->serialize();
    String* s2 = new String(fda2->serialize());
    system->t_true(s2->equals(s));
    //std::cout << "here\n";
    // for(int i = 0; i < 10; i++) {
    //     system->t_true(dfc->get(i) == i);
    // }
    system->OK("Passed DistributedIntColumn");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
pushq $0x1
popq %rdi
callq 0x7220
andq $0x0, -0x60(%rbp)
leaq 0x1d521(%rip), %rcx     # 0x26558
movq %rcx, -0x68(%rbp)
movq $0x1, -0x50(%rbp)
andq $0x0, -0x48(%rbp)
movq %rax, %rbx
andq $0x0, -0x28(%rbp)
movl $0x118, %edi            # imm = 0x118
callq 0x7220
movq %rax, %r14
pushq $0x1
popq %rsi
leaq -0x68(%rbp), %rcx
movq %rax, %rdi
xorl %edx, %edx
callq 0x9dd4
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xceb0
xorl %r12d, %r12d
movq (%r15), %rax
cmpl $0x28, %r12d
je 0x90a1
movq %r15, %rdi
movl %r12d, %esi
callq *0x98(%rax)
incl %r12d
jmp 0x9087
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r12
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xcf0c
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0xa064
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0xa064
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x911a
movq %rbx, %rdi
callq 0xf396
leaq 0x11327(%rip), %rsi     # 0x1a448
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x7280
leaq -0x68(%rbp), %rdi
callq 0xa00a
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9176
jmp 0x915d
jmp 0x9176
jmp 0x9153
jmp 0x9176
jmp 0x9176
movq %rax, %rbx
movq %r15, %rdi
jmp 0x916d
jmp 0x9176
movq %rax, %rbx
movq %r14, %rdi
jmp 0x916d
jmp 0x9176
movq %rax, %rbx
movq %r12, %rdi
callq 0x71f0
jmp 0x9179
jmp 0x9176
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0xa00a
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testDistributedDoubleColumn()
void testDistributedDoubleColumn() {
    Sys* system = new Sys();
    NetworkIP network;
    KVStore* kvs1 = new KVStore(1, 0, &network);
    DistributedDoubleColumn* dfc = new DistributedDoubleColumn(kvs1);
    for(int i = 0; i < 40; i++) {
        dfc->push_back(i);
    }
    char* serialized = dfc->serialize();
    //std::cout << serialized << "\n";   
    DistributedDoubleColumn* fda2 = new DistributedDoubleColumn(serialized, kvs1);
    String* s = new String(serialized);
    char* serial = fda2->serialize();
    String* s2 = new String(fda2->serialize());
    system->t_true(s2->equals(s));
    //std::cout << "here\n";
    // for(int i = 0; i < 10; i++) {
    //     system->t_true(dfc->get(i) == i);
    // }
    system->OK("Passed DistributedDoubleColumn");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
pushq $0x1
popq %rdi
callq 0x7220
andq $0x0, -0x60(%rbp)
leaq 0x1d3ab(%rip), %rcx     # 0x26558
movq %rcx, -0x68(%rbp)
movq $0x1, -0x50(%rbp)
andq $0x0, -0x48(%rbp)
movq %rax, %rbx
andq $0x0, -0x28(%rbp)
movl $0x118, %edi            # imm = 0x118
callq 0x7220
movq %rax, %r14
pushq $0x1
popq %rsi
leaq -0x68(%rbp), %rcx
movq %rax, %rdi
xorl %edx, %edx
callq 0x9dd4
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xcf96
xorl %r12d, %r12d
movq (%r15), %rax
cmpl $0x28, %r12d
je 0x9217
movq %r15, %rdi
movl %r12d, %esi
callq *0x98(%rax)
incl %r12d
jmp 0x91fd
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r12
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xcff2
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0xa064
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0xa064
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x9290
movq %rbx, %rdi
callq 0xf396
leaq 0x111cd(%rip), %rsi     # 0x1a464
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x7280
leaq -0x68(%rbp), %rdi
callq 0xa00a
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x92ec
jmp 0x92d3
jmp 0x92ec
jmp 0x92c9
jmp 0x92ec
jmp 0x92ec
movq %rax, %rbx
movq %r15, %rdi
jmp 0x92e3
jmp 0x92ec
movq %rax, %rbx
movq %r14, %rdi
jmp 0x92e3
jmp 0x92ec
movq %rax, %rbx
movq %r12, %rdi
callq 0x71f0
jmp 0x92ef
jmp 0x92ec
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0xa00a
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testDistributedFloatColumn()
void testDistributedFloatColumn() {
    Sys* system = new Sys();
    NetworkIP network;
    KVStore* kvs1 = new KVStore(1, 0, &network);
    DistributedFloatColumn* dfc = new DistributedFloatColumn(kvs1);
    for(int i = 0; i < 40; i++) {
        dfc->push_back(i);
    }
    char* serialized = dfc->serialize();
    //std::cout << serialized << "\n";   
    DistributedFloatColumn* fda2 = new DistributedFloatColumn(serialized, kvs1);
    String* s = new String(serialized);
    char* serial = fda2->serialize();
    String* s2 = new String(fda2->serialize());
    system->t_true(s2->equals(s));
    //std::cout << "here\n";
    // for(int i = 0; i < 10; i++) {
    //     system->t_true(dfc->get(i) == i);
    // }
    system->OK("Passed DistributedFloatColumn");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
pushq $0x1
popq %rdi
callq 0x7220
andq $0x0, -0x60(%rbp)
leaq 0x1d235(%rip), %rcx     # 0x26558
movq %rcx, -0x68(%rbp)
movq $0x1, -0x50(%rbp)
andq $0x0, -0x48(%rbp)
movq %rax, %rbx
andq $0x0, -0x28(%rbp)
movl $0x118, %edi            # imm = 0x118
callq 0x7220
movq %rax, %r14
pushq $0x1
popq %rsi
leaq -0x68(%rbp), %rcx
movq %rax, %rdi
xorl %edx, %edx
callq 0x9dd4
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xd07c
xorl %r12d, %r12d
movq (%r15), %rax
cmpl $0x28, %r12d
je 0x938d
movq %r15, %rdi
movl %r12d, %esi
callq *0x98(%rax)
incl %r12d
jmp 0x9373
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r12
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xd0d8
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0xa064
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0xa064
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x9406
movq %rbx, %rdi
callq 0xf396
leaq 0x11076(%rip), %rsi     # 0x1a483
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x7280
leaq -0x68(%rbp), %rdi
callq 0xa00a
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9462
jmp 0x9449
jmp 0x9462
jmp 0x943f
jmp 0x9462
jmp 0x9462
movq %rax, %rbx
movq %r15, %rdi
jmp 0x9459
jmp 0x9462
movq %rax, %rbx
movq %r14, %rdi
jmp 0x9459
jmp 0x9462
movq %rax, %rbx
movq %r12, %rdi
callq 0x71f0
jmp 0x9465
jmp 0x9462
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0xa00a
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testDistributedBoolColumn()
void testDistributedBoolColumn() {
    Sys* system = new Sys();
    NetworkIP network;
    KVStore* kvs1 = new KVStore(1, 0, &network);
    DistributedBoolColumn* dfc = new DistributedBoolColumn(kvs1);
    for(int i = 0; i < 40; i++) {
        dfc->push_back(i);
    }
    char* serialized = dfc->serialize();
    //std::cout << serialized << "\n";   
    DistributedBoolColumn* fda2 = new DistributedBoolColumn(serialized, kvs1);
    String* s = new String(serialized);
    char* serial = fda2->serialize();
    String* s2 = new String(fda2->serialize());
    system->t_true(s2->equals(s));
    //std::cout << "here\n";
    // for(int i = 0; i < 10; i++) {
    //     system->t_true(dfc->get(i) == i);
    // }
    system->OK("Passed DistributedBoolColumn");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
pushq $0x1
popq %rdi
callq 0x7220
andq $0x0, -0x60(%rbp)
leaq 0x1d0bf(%rip), %rcx     # 0x26558
movq %rcx, -0x68(%rbp)
movq $0x1, -0x50(%rbp)
andq $0x0, -0x48(%rbp)
movq %rax, %rbx
andq $0x0, -0x28(%rbp)
movl $0x118, %edi            # imm = 0x118
callq 0x7220
movq %rax, %r14
pushq $0x1
popq %rsi
leaq -0x68(%rbp), %rcx
movq %rax, %rdi
xorl %edx, %edx
callq 0x9dd4
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xd162
xorl %r12d, %r12d
movq (%r15), %rax
cmpl $0x28, %r12d
je 0x9503
movq %r15, %rdi
movl %r12d, %esi
callq *0x98(%rax)
incl %r12d
jmp 0x94e9
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r12
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xd1be
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0xa064
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0xa064
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x957c
movq %rbx, %rdi
callq 0xf396
leaq 0x10f1e(%rip), %rsi     # 0x1a4a1
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x7280
leaq -0x68(%rbp), %rdi
callq 0xa00a
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x95d8
jmp 0x95bf
jmp 0x95d8
jmp 0x95b5
jmp 0x95d8
jmp 0x95d8
movq %rax, %rbx
movq %r15, %rdi
jmp 0x95cf
jmp 0x95d8
movq %rax, %rbx
movq %r14, %rdi
jmp 0x95cf
jmp 0x95d8
movq %rax, %rbx
movq %r12, %rdi
callq 0x71f0
jmp 0x95db
jmp 0x95d8
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0xa00a
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/tests/testSerialize.cpp
// Function: testDistributedStringColumn()
void testDistributedStringColumn() {
    Sys* system = new Sys();
    NetworkIP network;
    KVStore* kvs1 = new KVStore(1, 0, &network);
    DistributedStringColumn* dfc = new DistributedStringColumn(kvs1);
    for(int i = 0; i < 40; i++) {
        dfc->push_back(i);
    }
    char* serialized = dfc->serialize();
    //std::cout << serialized << "\n";   
    DistributedStringColumn* fda2 = new DistributedStringColumn(serialized, kvs1);
    String* s = new String(serialized);
    char* serial = fda2->serialize();
    String* s2 = new String(fda2->serialize());
    system->t_true(s2->equals(s));
    //std::cout << "here\n";
    // for(int i = 0; i < 10; i++) {
    //     system->t_true(dfc->get(i) == i);
    // }
    system->OK("Passed DistributedStringColumn");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
pushq $0x1
popq %rdi
callq 0x7220
andq $0x0, -0x60(%rbp)
leaq 0x1cf49(%rip), %rcx     # 0x26558
movq %rcx, -0x68(%rbp)
movq $0x1, -0x50(%rbp)
andq $0x0, -0x48(%rbp)
movq %rax, %rbx
andq $0x0, -0x28(%rbp)
movl $0x118, %edi            # imm = 0x118
callq 0x7220
movq %rax, %r14
pushq $0x1
popq %rsi
leaq -0x68(%rbp), %rcx
movq %rax, %rdi
xorl %edx, %edx
callq 0x9dd4
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xd248
xorl %r12d, %r12d
movq (%r15), %rax
cmpl $0x28, %r12d
je 0x9679
movq %r15, %rdi
movl %r12d, %esi
callq *0x98(%rax)
incl %r12d
jmp 0x965f
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r12
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xd2a4
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
callq 0xa064
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r12
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0xa064
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x96f2
movq %rbx, %rdi
callq 0xf396
leaq 0x10dc5(%rip), %rsi     # 0x1a4be
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x7280
leaq -0x68(%rbp), %rdi
callq 0xa00a
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x974e
jmp 0x9735
jmp 0x974e
jmp 0x972b
jmp 0x974e
jmp 0x974e
movq %rax, %rbx
movq %r15, %rdi
jmp 0x9745
jmp 0x974e
movq %rax, %rbx
movq %r14, %rdi
jmp 0x9745
jmp 0x974e
movq %rax, %rbx
movq %r12, %rdi
callq 0x71f0
jmp 0x9751
jmp 0x974e
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0xa00a
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq $0x1
popq %rdi
callq 0x7220
movq %rax, %rbx
pushq $0x50
popq %rdi
callq 0x7220
movq %rax, %r14
leaq 0x10d53(%rip), %rsi     # 0x1a4dd
movq %rax, %rdi
callq 0xd32e
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, %r14
pushq $0x50
popq %rdi
callq 0x7220
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0xd49a
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xa064
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r14
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0xa064
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x9802
movq %rbx, %rdi
callq 0xf396
leaq 0x10cd8(%rip), %rsi     # 0x1a4e1
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7280
movq %rax, %rbx
movq %r15, %r14
jmp 0x9836
movq %rax, %rbx
movq %r12, %r14
jmp 0x9836
jmp 0x9833
movq %rax, %rbx
movq %r14, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x50, %rsp
pushq $0x1
popq %rdi
callq 0x7220
andq $0x0, -0x50(%rbp)
leaq 0x1cac3(%rip), %rcx     # 0x26558
movq %rcx, -0x58(%rbp)
movq $0x1, -0x40(%rbp)
andq $0x0, -0x38(%rbp)
movq %rax, %rbx
andq $0x0, -0x18(%rbp)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r14
leaq -0x58(%rbp), %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0xdac0
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
leaq 0x10a34(%rip), %rsi     # 0x1a50b
movq %rbx, %rdi
callq 0xf3ae
movq %rbx, %rdi
callq 0x7280
leaq -0x58(%rbp), %rdi
callq 0xa00a
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x71f0
jmp 0x9b09
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xa00a
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/tests/testSerialize.cpp
// Function: tryMap()
void tryMap() {
    Value* v1 = new Value("muffin", (size_t)6);
    Value* v3 = new Value("carrot", (size_t)6);
    Key* k1 = new Key("payload_1", 0);
    Key* k3 = new Key("payload_1", 0);
    char* c1 =  "payload_1";
    char* c2 = "payload_3";

    std::map<Key*, Value*, KeyCompare> store;
    std::map<Key, Value>::iterator it;
    store.insert(std::pair<Key*, Value*>(k1, v1));

    std::cout << (c1 < c2)  <<"\n";
    std::cout <<  store.find(k1)->second->serialize() <<"\n";
    store.find(k3)->second = v3;   
    std::cout <<  store.find(k1)->second->serialize() <<"\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
pushq $0x20
popq %r15
movq %r15, %rdi
callq 0x7220
movq %rax, %r14
andq $0x0, 0x8(%rax)
leaq 0x1c872(%rip), %r12     # 0x263b8
movq %r12, (%rax)
leaq 0x10550(%rip), %rax     # 0x1a0a0
movq %rax, 0x10(%r14)
pushq $0x6
popq %r13
movq %r13, 0x18(%r14)
movq %r15, %rdi
callq 0x7220
movq %rax, %rbx
andq $0x0, 0x8(%rax)
movq %r12, (%rax)
leaq 0x10531(%rip), %rax     # 0x1a0a7
movq %rax, 0x10(%rbx)
movq %r13, 0x18(%rbx)
movq %r15, %rdi
callq 0x7220
movq %rax, %r15
leaq 0x1051e(%rip), %rsi     # 0x1a0ae
movq %rax, %rdi
xorl %edx, %edx
callq 0x9d76
movq %r15, -0x30(%rbp)
pushq $0x20
popq %rdi
callq 0x7220
movq %rax, %r13
leaq 0x104fe(%rip), %r12     # 0x1a0ae
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x9d76
leaq -0x60(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq %r13, -0x38(%rbp)
leaq -0x78(%rbp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
leaq -0x68(%rbp), %rdi
callq 0x1789a
leaq 0x104c3(%rip), %rax     # 0x1a0b8
xorl %esi, %esi
cmpq %rax, %r12
setb %sil
movq 0x1e3c3(%rip), %rdi     # 0x27fc8
callq 0x7310
leaq 0x10ae3(%rip), %rsi     # 0x1a6f4
movq %rax, %rdi
callq 0x7210
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17aba
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x1e391(%rip), %rdi     # 0x27fc8
movq %rax, %rsi
callq 0x7210
leaq 0x10aae(%rip), %rsi     # 0x1a6f4
movq %rax, %rdi
callq 0x7210
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x17aba
movq %rbx, 0x28(%rax)
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17aba
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x1e34b(%rip), %rdi     # 0x27fc8
movq %rax, %rsi
callq 0x7210
leaq 0x10a68(%rip), %rsi     # 0x1a6f4
movq %rax, %rdi
callq 0x7210
leaq -0x68(%rbp), %rdi
callq 0x17844
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9cc9
jmp 0x9cc9
movq %rax, %rbx
movq %r13, %rdi
jmp 0x9cbe
movq %rax, %rbx
movq %r15, %rdi
callq 0x71f0
jmp 0x9cd5
jmp 0x9cc9
jmp 0x9cc9
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x17844
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8833
callq 0x892b
callq 0x7d14
callq 0x7e07
callq 0x782f
callq 0x79ba
callq 0x7b35
callq 0x7c2e
callq 0x7eed
callq 0x7fd9
callq 0x809c
callq 0x8162
callq 0x826f
callq 0x834e
callq 0x842d
callq 0x84fe
callq 0x85cf
callq 0x86a8
callq 0x8af7
callq 0x8c7f
callq 0x8e62
callq 0x9014
callq 0x918a
callq 0x9300
callq 0x9476
callq 0x95ec
callq 0x9762
callq 0x9846
callq 0x9a76
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xd8, %rsp
movl %esi, -0x2c(%rbp)
movq %rdi, %rbx
movq %rdx, -0xf0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %r8, -0xe0(%rbp)
movq %r9, -0xd8(%rbp)
testb %al, %al
je 0xa1e5
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
andq $0x0, 0x8(%rdi)
leaq 0x1c79f(%rip), %rax     # 0x26990
movq %rax, (%rdi)
movabsq $0x40000000000, %rax    # imm = 0x40000000000
movq %rax, 0x18(%rdi)
movl $0xa, 0x20(%rdi)
pushq $0x28
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
callq 0xe5ae
movq %r15, 0x10(%rbx)
xorl %r14d, %r14d
pushq $0x28
popq %r12
cmpl 0x20(%rbx), %r14d
jge 0xa259
movq 0x10(%rbx), %r13
movq %r12, %rdi
callq 0x7220
movq %rax, %r15
movl 0x1c(%rbx), %esi
movq %rax, %rdi
callq 0xa136
movq (%r13), %rax
movq %r13, %rdi
movq %r15, %rsi
callq *0x58(%rax)
incl %r14d
jmp 0xa227
leaq -0x100(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x50(%rbp)
xorl %r15d, %r15d
movl -0x2c(%rbp), %eax
testl %eax, %eax
cmovgl %eax, %r15d
subl $0x1, %r15d
jb 0xa2c5
movl -0x4c(%rbp), %ecx
cmpq $0xa0, %rcx
ja 0xa2a7
movq %rcx, %rax
addq -0x40(%rbp), %rax
addl $0x10, %ecx
movl %ecx, -0x4c(%rbp)
jmp 0xa2b3
movq -0x48(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x48(%rbp)
movss (%rax), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xb0(%rax)
jmp 0xa286
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa2d9
movq %rax, %rbx
movq %r15, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xd8, %rsp
movl %esi, -0x2c(%rbp)
movq %rdi, %rbx
movq %rdx, -0xf0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %r8, -0xe0(%rbp)
movq %r9, -0xd8(%rbp)
testb %al, %al
je 0xa39b
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
andq $0x0, 0x8(%rdi)
leaq 0x1c721(%rip), %rax     # 0x26ac8
movq %rax, (%rdi)
movabsq $0x40000000000, %rax    # imm = 0x40000000000
movq %rax, 0x18(%rdi)
movl $0xa, 0x20(%rdi)
pushq $0x28
popq %rdi
callq 0x7220
movq %rax, %r15
movq %rax, %rdi
callq 0xe5ae
movq %r15, 0x10(%rbx)
xorl %r14d, %r14d
pushq $0x28
popq %r12
cmpl 0x20(%rbx), %r14d
jge 0xa40f
movq 0x10(%rbx), %r13
movq %r12, %rdi
callq 0x7220
movq %rax, %r15
movl 0x1c(%rbx), %esi
movq %rax, %rdi
callq 0xa2ec
movq (%r13), %rax
movq %r13, %rdi
movq %r15, %rsi
callq *0x58(%rax)
incl %r14d
jmp 0xa3dd
leaq -0x100(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x50(%rbp)
xorl %r15d, %r15d
movl -0x2c(%rbp), %eax
testl %eax, %eax
cmovgl %eax, %r15d
subl $0x1, %r15d
jb 0xa476
movl -0x50(%rbp), %ecx
cmpq $0x28, %rcx
ja 0xa45a
movq %rcx, %rax
addq -0x40(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x50(%rbp)
jmp 0xa466
movq -0x48(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x48(%rbp)
movl (%rax), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x98(%rax)
jmp 0xa43c
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa48a
movq %rax, %rbx
movq %r15, %rdi
callq 0x71f0
movq %rbx, %rdi
callq 0x7330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0xf4240, %rax          # imm = 0xF4240
je 0x1751e
cvtsi2sd %rax, %xmm0
movsd %xmm0, (%rbx,%rax,8)
addsd %xmm0, %xmm1
incq %rax
jmp 0x17503
movsd %xmm1, -0x20(%rbp)
leaq 0x36be(%rip), %rsi      # 0x1abe8
leaq -0x40(%rbp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x9d76
movq 0x10(%r14), %rsi
movl $0xf4240, %edx          # imm = 0xF4240
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1765c
movq %rax, %rbx
pushq $0x1
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1776e
cmpl $0x1, %eax
jne 0x17615
pushq $0x1
popq %rdi
callq 0x7220
movq %rax, %r15
movq 0x10(%r14), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1138c
movq 0x10(%rax), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0x1818e
testq %rax, %rax
je 0x175af
leaq 0xed4f(%rip), %rsi      # 0x262e8
leaq 0x10698(%rip), %rdx     # 0x27c38
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7250
movq %rax, %r14
jmp 0x175b2
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq $0xf4240, %r15          # imm = 0xF4240
je 0x175e2
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1776e
cvtsi2sd %eax, %xmm0
movsd -0x20(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, -0x20(%rbp)
incq %r15
jmp 0x175b5
xorpd %xmm0, %xmm0
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x1762e
jp 0x1762e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
testq %r14, %r14
je 0x1760a
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35d1(%rip), %rdi      # 0x1abed
leaq 0x35e3(%rip), %rsi      # 0x1ac06
leaq 0x35ff(%rip), %rcx      # 0x1ac29
pushq $0x2e
jmp 0x17645
leaq 0x3611(%rip), %rdi      # 0x1ac46
leaq 0x35ca(%rip), %rsi      # 0x1ac06
leaq 0x35e6(%rip), %rcx      # 0x1ac29
pushq $0x32
popq %rdx
callq 0x7150
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
movslq (%rdi), %rax
movq (%rsi), %rcx
xorl %r8d, %r8d
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
movl %eax, %esi
negl %esi
movq %r8, %rdi
cmpq %r8, %rdx
je 0x23da
movl (%rcx,%rdi,4), %r8d
subl (%rcx,%rax,4), %r8d
je 0x23da
movl %r8d, %r9d
negl %r9d
cmovsl %r8d, %r9d
leal (%rsi,%rdi), %r8d
movl %r8d, %r10d
negl %r10d
cmovsl %r8d, %r10d
leaq 0x1(%rdi), %r8
cmpl %r10d, %r9d
jne 0x23a7
cmpq %rax, %rdi
setge %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
xorl %r12d, %r12d
leaq 0x1c07(%rip), %r15      # 0x4004
movq 0x3bd4(%rip), %r14      # 0x5fd8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r12, %rdx
jbe 0x247f
xorl %r13d, %r13d
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x2463
leal (%r12,%r13), %edx
leaq 0x1bd9(%rip), %rcx      # 0x400d
testb $0x1, %dl
je 0x2440
leaq 0x1bd5(%rip), %rcx      # 0x4015
movl (%rax,%r12,4), %eax
movq %r15, %rsi
cmpq %rax, %r13
je 0x244f
movq %rcx, %rsi
movq %r14, %rdi
callq 0x2130
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
jmp 0x241d
movq %r14, %rdi
leaq 0x1bb0(%rip), %rsi      # 0x401d
callq 0x2130
movq %rax, %rdi
callq 0x20a0
incq %r12
jmp 0x2404
movq 0x3b52(%rip), %rdi      # 0x5fd8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
xorl %r13d, %r13d
leaq 0x1b6a(%rip), %r15      # 0x4021
leaq -0x40(%rbp), %r12
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq %r14, %rax
jbe 0x251c
movq 0x3aff(%rip), %rdi      # 0x5fd8
movq %r15, %rsi
callq 0x2130
leal 0x1(%r14), %esi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x20a0
movq (%rbx), %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0x28b6
movq %r12, %rdi
callq 0x23e2
movq %r12, %rdi
callq 0x2f10
addq $0x18, %r13
incq %r14
jmp 0x24be
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2f10
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21d0
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movl %eax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
callq 0x2b6c
leaq -0x20(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x31ce
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x253f
movq 0x3781(%rip), %rdi      # 0x5fd8
leaq -0x40(%rbp), %rsi
callq 0x20f0
leaq -0x40(%rbp), %rdi
callq 0x2080
leaq -0x20(%rbp), %rdi
callq 0x2c46
leaq -0x70(%rbp), %rdi
callq 0x2c46
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2080
jmp 0x2895
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x2c46
jmp 0x28a5
jmp 0x28a2
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2c46
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x4, 0x18(%rdi)
jl 0x2c22
movq %rdi, %rbx
callq 0x2dd6
movslq 0x18(%rbx), %rsi
leaq -0x2c(%rbp), %r14
orl $-0x1, (%r14)
leaq -0x48(%rbp), %rdi
leaq -0x2d(%rbp), %rcx
movq %r14, %rdx
callq 0x2de4
andl $0x0, (%r14)
xorl %eax, %eax
movl %eax, %r12d
testl %r12d, %r12d
js 0x2c19
movq -0x48(%rbp), %r13
movl (%r13,%r12,4), %r14d
incl %r14d
movl %r14d, (%r13,%r12,4)
movl 0x18(%rbx), %r15d
cmpl %r15d, %r14d
jge 0x2bfd
leaq -0x2c(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x238c
incl %r14d
testb %al, %al
je 0x2bc5
decl %r15d
cmpl %r15d, %r12d
jne 0x2c09
movq %rbx, %rdi
leaq -0x48(%rbp), %rsi
callq 0x2e44
jmp 0x2bb4
decl %r12d
movl %r12d, -0x2c(%rbp)
movl %r12d, %eax
jmp 0x2bb1
leal 0x1(%r12), %eax
movl %eax, -0x2c(%rbp)
orl $-0x1, 0x4(%r13,%r12,4)
jmp 0x2bb1
leaq -0x48(%rbp), %rdi
callq 0x2f10
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2f10
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/ridgelab[P]Kmer-SSR/test/src/findSSRs.cpp
// Function: main
int main()
{
	cout << '\n';
	
	int ret_val = 0; // also used to count the number of failed tests

	vector<bool (*)()> tests = {
		test1, test2, test3, test4, test5,
		test6, test7, test8, test9, test10,
		test11, test12
	};

	for (uint32_t i = 0; i < tests.size(); ++i)
	{
		cout << "FindSSRs Test #" << i + 1 << ":\t";
		if (tests[i]())
		{
			cout << "OK";
		}
		else
		{
			++ret_val;
			cout << "FAIL";
		}
		cout << '\n';

		optind = 1; // reset optind for next use of global getopt
	}
	
	string pass_or_fail_color = ret_val ? "\033[0;31m" : "\033[0;32m";
	cout << "\033[0;34mFindSSRs Passed:\t" << pass_or_fail_color << tests.size() - ret_val << " / " << tests.size() << "\033[0m" << endl;
	
	return ret_val;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq 0x1473c(%rip), %r14     # 0x18fc0
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x4360
leaq 0x13ffa(%rip), %rsi     # 0x18890
pushq $0xc
popq %rdx
leaq 0x28(%rsp), %rax
movq %rdx, %rcx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movq %rax, %rsi
callq 0x654c
xorl %ebx, %ebx
pushq $0x1
popq %r13
leaq 0xa77c(%rip), %r12      # 0xf042
movq 0x14703(%rip), %rbp     # 0x18fd0
leal -0x1(%r13), %r15d
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x4952
movq %r14, %rdi
leaq 0xa716(%rip), %rsi      # 0xf004
callq 0x42e0
movl %r13d, %esi
movq %rax, %rdi
callq 0x41f0
movq %rax, %rdi
movq %r12, %rsi
callq 0x42e0
movq 0x10(%rsp), %rax
callq *(%rax,%r15,8)
testb %al, %al
je 0x4927
movq %r14, %rdi
leaq 0xa6f4(%rip), %rsi      # 0xf014
callq 0x42e0
jmp 0x4938
movq %r14, %rdi
leaq 0xa6e6(%rip), %rsi      # 0xf017
callq 0x42e0
incl %ebx
movq %r14, %rdi
pushq $0xa
popq %rsi
callq 0x4360
movl $0x1, (%rbp)
incl %r13d
jmp 0x48cd
testl %ebx, %ebx
leaq 0xa6c9(%rip), %rax      # 0xf024
leaq 0xa6ba(%rip), %rsi      # 0xf01c
cmoveq %rax, %rsi
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6582
movq 0x14644(%rip), %rdi     # 0x18fc0
leaq 0xa6a9(%rip), %rsi      # 0xf02c
callq 0x42e0
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x42c0
movq 0x18(%rsp), %rsi
subq 0x10(%rsp), %rsi
sarq $0x3, %rsi
movslq %ebx, %rcx
subq %rcx, %rsi
movq %rax, %rdi
callq 0x41f0
leaq 0xa68d(%rip), %rsi      # 0xf045
movq %rax, %rdi
callq 0x42e0
movq 0x18(%rsp), %rsi
subq 0x10(%rsp), %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0x41f0
leaq 0xbab2(%rip), %rsi      # 0x1048f
movq %rax, %rdi
callq 0x42e0
movq %rax, %rdi
callq 0x4160
leaq 0x28(%rsp), %rdi
callq 0x45e8
leaq 0x10(%rsp), %rdi
callq 0x6692
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4a26
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x45e8
jmp 0x4a29
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6692
movq %rbx, %rdi
callq 0x4560