LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yasz24[P]eau2/tests/testSerialize.cpp
// Function: testWaitAndGetSerialization()
void testWaitAndGetSerialization() {
    Sys* tester = new Sys();
    Key k("key1", 0);
    WaitAndGet ack(&k, 1,2,3);
    char* msg_serialized = ack.serialize();
    WaitAndGet* msg_two = new WaitAndGet(msg_serialized);
    tester->t_true(strcmp(msg_serialized, msg_two->serialize()) == 0);
    tester->OK("Passed Get Serialization Tests");
    delete tester;
    delete msg_two;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x1, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
callq 0xcd20
jmp 0x91a9
movq -0x88(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x26127(%rip), %rsi     # 0x2f2e2
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xc780
movq -0x90(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movl $0x1, %edx
movl $0x2, %ecx
movl $0x3, %r8d
callq 0xf210
jmp 0x91f1
leaq -0x70(%rbp), %rdi
callq 0xf280
movq %rax, -0x98(%rbp)
jmp 0x9203
movq -0x98(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x38, %edi
callq 0x7250
movq %rax, -0xa0(%rbp)
jmp 0x9221
movq -0xa0(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xf3b0
jmp 0x9233
movq -0xa0(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0xa8(%rbp)
jmp 0x926a
movq -0xa8(%rbp), %rsi
movq -0xb0(%rbp), %rdi
callq 0x72d0
movq -0xb8(%rbp), %rdi
testl %eax, %eax
sete %al
movzbl %al, %esi
callq 0xcd30
jmp 0x9293
movq -0x8(%rbp), %rdi
leaq 0x2606c(%rip), %rsi     # 0x2f30a
callq 0xcd70
jmp 0x92a5
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpq $0x0, %rax
je 0x92c2
movq -0xc0(%rbp), %rdi
callq 0x7220
movq -0x80(%rbp), %rax
movq %rax, -0xc8(%rbp)
cmpq $0x0, %rax
je 0x92e0
movq -0xc8(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x70(%rbp), %rdi
callq 0xf820
leaq -0x38(%rbp), %rdi
callq 0xebc0
addq $0xd0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0x935b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x9352
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x9349
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
leaq -0x70(%rbp), %rdi
callq 0xf820
leaq -0x38(%rbp), %rdi
callq 0xebc0
movq -0x10(%rbp), %rdi
callq 0x7370
nopw %cs:(%rax,%rax)
// File: yasz24[P]eau2/tests/testSerialize.cpp
// Function: testStatusSerialization()
void testStatusSerialization() {
    Sys* tester = new Sys();
    Status ack("status", 1,2,3);
    char* msg_serialized = ack.serialize();
    Status* msg_two = new Status(msg_serialized);
    tester->t_true(strcmp(msg_serialized, msg_two->serialize()) == 0);
    tester->OK("Passed Status Serialization Tests");
    delete tester;
    delete msg_two;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x1, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0xcd20
jmp 0x9396
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x25f84(%rip), %rsi     # 0x2f329
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x1, %edx
movl $0x2, %ecx
movl $0x3, %r8d
callq 0xf840
movq -0x78(%rbp), %rdi
callq 0xf8b0
movq %rax, -0x70(%rbp)
jmp 0x93d1
movq -0x70(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x38, %edi
callq 0x7250
movq %rax, -0x80(%rbp)
jmp 0x93e9
movq -0x80(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xf9d0
jmp 0x93f8
movq -0x80(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0x88(%rbp)
jmp 0x942c
movq -0x88(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0x72d0
movq -0x98(%rbp), %rdi
testl %eax, %eax
sete %al
movzbl %al, %esi
callq 0xcd30
jmp 0x9455
movq -0x8(%rbp), %rdi
leaq 0x25ed0(%rip), %rsi     # 0x2f330
callq 0xcd70
jmp 0x9467
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x9484
movq -0xa0(%rbp), %rdi
callq 0x7220
movq -0x60(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0x94a2
movq -0xa8(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x50(%rbp), %rdi
callq 0xfe00
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0x94f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x94ee
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
leaq -0x50(%rbp), %rdi
callq 0xfe00
movq -0x10(%rbp), %rdi
callq 0x7370
// File: yasz24[P]eau2/tests/testSerialize.cpp
// Function: testReplySerialization()
void testReplySerialization() {
    Sys* tester = new Sys();
    Reply ack("status", 1,2,3);
    char* msg_serialized = ack.serialize();
    //std::cout << msg_serialized << "\n";
    Reply* msg_two = new Reply(msg_serialized);
    //std::cout << msg_two->serialize() << "\n";
    tester->t_true(strcmp(msg_serialized, msg_two->serialize()) == 0);
    tester->OK("Passed Reply Serialization Tests");
    delete tester;
    delete msg_two;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x1, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0xcd20
jmp 0x9526
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x25df4(%rip), %rsi     # 0x2f329
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x1, %edx
movl $0x2, %ecx
movl $0x3, %r8d
callq 0xfe20
movq -0x78(%rbp), %rdi
callq 0xfe90
movq %rax, -0x70(%rbp)
jmp 0x9561
movq -0x70(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x38, %edi
callq 0x7250
movq %rax, -0x80(%rbp)
jmp 0x9579
movq -0x80(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xffe0
jmp 0x9588
movq -0x80(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0x88(%rbp)
jmp 0x95bc
movq -0x88(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0x72d0
movq -0x98(%rbp), %rdi
testl %eax, %eax
sete %al
movzbl %al, %esi
callq 0xcd30
jmp 0x95e5
movq -0x8(%rbp), %rdi
leaq 0x25d62(%rip), %rsi     # 0x2f352
callq 0xcd70
jmp 0x95f7
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x9614
movq -0xa0(%rbp), %rdi
callq 0x7220
movq -0x60(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0x9632
movq -0xa8(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x50(%rbp), %rdi
callq 0x104e0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0x9687
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x967e
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
leaq -0x50(%rbp), %rdi
callq 0x104e0
movq -0x10(%rbp), %rdi
callq 0x7370
// File: yasz24[P]eau2/tests/testSerialize.cpp
// Function: testRegisterSerialization()
void testRegisterSerialization() {
    Sys* tester = new Sys();
    Register ack(1,2,3, "127.0.0.1", 3001);
    char* msg_serialized = ack.serialize();
    Register* msg_two = new Register(msg_serialized);
    tester->t_true(strcmp(msg_serialized, msg_two->serialize()) == 0);
    tester->OK("Passed Register Serialization Tests");
    delete tester;
    delete msg_two;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x1, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0xcd20
jmp 0x96b6
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x25cae(%rip), %r8      # 0x2f373
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x1, %esi
movl $0x2, %edx
movl $0x3, %ecx
movl $0xbb9, %r9d            # imm = 0xBB9
callq 0x10500
movq -0x80(%rbp), %rdi
callq 0x10580
movq %rax, -0x78(%rbp)
jmp 0x96f6
movq -0x78(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x40, %edi
callq 0x7250
movq %rax, -0x88(%rbp)
jmp 0x9711
movq -0x88(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x106c0
jmp 0x9723
movq -0x88(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0x90(%rbp)
jmp 0x975a
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdi
callq 0x72d0
movq -0xa0(%rbp), %rdi
testl %eax, %eax
sete %al
movzbl %al, %esi
callq 0xcd30
jmp 0x9783
movq -0x8(%rbp), %rdi
leaq 0x25bef(%rip), %rsi     # 0x2f37d
callq 0xcd70
jmp 0x9795
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0x97b2
movq -0xa8(%rbp), %rdi
callq 0x7220
movq -0x68(%rbp), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x0, %rax
je 0x97d0
movq -0xb0(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x58(%rbp), %rdi
callq 0x10bd0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0x9828
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x981f
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
leaq -0x58(%rbp), %rdi
callq 0x10bd0
movq -0x10(%rbp), %rdi
callq 0x7370
nopw %cs:(%rax,%rax)
// File: yasz24[P]eau2/tests/testSerialize.cpp
// Function: testValueSerialization()
void testValueSerialization() {
    Sys* system = new Sys();
    Value* v1 = new Value("muffin", (size_t)6);
    Value* v3 = new Value("carrot", (size_t)6);
    char* serialized = v1->serialize();
    Value* v2 = new Value(serialized);
    system->t_true(v1->equals(v2));
    system->t_false(v3->equals(v2));
    system->OK("Passed value serialization");
    delete [] system;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x1, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0xcd20
jmp 0x9ba3
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x20, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x2551a(%rip), %rsi     # 0x2f0e0
movl $0x6, %edx
callq 0xc730
jmp 0x9bd2
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x20, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x254f2(%rip), %rsi     # 0x2f0e7
movl $0x6, %edx
callq 0xc730
jmp 0x9c01
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0x30(%rbp)
movl $0x20, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rsi
callq 0x11510
jmp 0x9c39
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x70(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0xcd30
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x68(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x11760
movq -0x8(%rbp), %rdi
leaq 0x2574b(%rip), %rsi     # 0x2f3e1
callq 0xcd70
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x9cb2
movq -0x60(%rbp), %rdi
callq 0x72b0
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0x9d12
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0x9d12
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0x9d12
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
movq -0x10(%rbp), %rdi
callq 0x7370
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movl $0x1, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0xcd20
jmp 0x9d43
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x20, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x2537a(%rip), %rsi     # 0x2f0e0
xorl %eax, %eax
movl %eax, %edx
callq 0xc780
jmp 0x9d71
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x20, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x25353(%rip), %rsi     # 0x2f0e7
xorl %eax, %eax
movl %eax, %edx
callq 0xc780
jmp 0x9d9f
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0x30(%rbp)
movl $0x20, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rsi
callq 0x117a0
jmp 0x9dd7
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x70(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0xcd30
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x68(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x11760
movq -0x8(%rbp), %rdi
leaq 0x255c8(%rip), %rsi     # 0x2f3fc
callq 0xcd70
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x9e50
movq -0x60(%rbp), %rdi
callq 0x72b0
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0x9eb0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0x9eb0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0x9eb0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
movq -0x10(%rbp), %rdi
callq 0x7370
nopl (%rax)
// File: 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
subq $0x80, %rsp
movl $0x1, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0xcd20
jmp 0x9ee6
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
callq 0x7560
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0x28(%rbp)
movl $0x118, %edi            # imm = 0x118
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rsi
callq 0x11950
jmp 0x9f27
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0x38(%rbp)
movl $0x20, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rsi
callq 0xcce0
jmp 0x9f5f
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x20, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rsi
callq 0xcce0
jmp 0x9f86
movq -0x68(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x78(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0xcd30
movq -0x8(%rbp), %rdi
leaq 0x25457(%rip), %rsi     # 0x2f415
callq 0xcd70
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x9fdb
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x9ff2
movq -0x80(%rbp), %rdi
callq 0x72b0
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0xa055
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0xa055
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0xa055
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
movq -0x10(%rbp), %rdi
callq 0x7370
nop
// File: 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
subq $0x80, %rsp
movl $0x1, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0xcd20
jmp 0xbb66
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x50, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x23994(%rip), %rsi     # 0x2f51d
callq 0x141a0
jmp 0xbb90
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0x28(%rbp)
movl $0x50, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rsi
callq 0x14470
jmp 0xbbc8
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x20, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rsi
callq 0xcce0
jmp 0xbbef
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x20, %edi
callq 0x7250
movq %rax, -0x70(%rbp)
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0x68(%rbp)
jmp 0xbc18
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0xcce0
jmp 0xbc27
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x80(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0xcd30
movq -0x8(%rbp), %rdi
leaq 0x238c2(%rip), %rsi     # 0x2f521
callq 0xcd70
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0xbc7b
movq -0x78(%rbp), %rdi
callq 0x72b0
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0xbcf5
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0xbcf5
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0xbcf5
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0xbcf5
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
movq -0x10(%rbp), %rdi
callq 0x7370
nop
// File: 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
subq $0x80, %rsp
movl $0x1, %edi
callq 0x7250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0xcd20
jmp 0xc1b6
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xc820
movl $0x20, %edi
callq 0x7250
movq %rax, -0x78(%rbp)
jmp 0xc1d7
movq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x60(%rbp), %rdx
callq 0x15300
jmp 0xc1ea
movq -0x78(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq 0x40(%rax), %rax
callq *%rax
jmp 0xc201
movq -0x8(%rbp), %rdi
leaq 0x2333f(%rip), %rsi     # 0x2f54b
callq 0xcd70
jmp 0xc213
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0xc22a
movq -0x80(%rbp), %rdi
callq 0x72b0
leaq -0x60(%rbp), %rdi
callq 0xcbe0
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
jmp 0xc27f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xc276
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x7220
leaq -0x60(%rbp), %rdi
callq 0xcbe0
movq -0x10(%rbp), %rdi
callq 0x7370
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x9b80
callq 0x9d20
callq 0x84f0
callq 0x86b0
callq 0x7b20
callq 0x7e30
callq 0x8160
callq 0x8320
callq 0x8880
callq 0x8a30
callq 0x8bc0
callq 0x8d50
callq 0x8f90
callq 0x9180
callq 0x9370
callq 0x9500
callq 0x9690
callq 0x9840
callq 0xa060
callq 0xa3a0
callq 0xa7b0
callq 0xab50
callq 0xae80
callq 0xb1b0
callq 0xb4e0
callq 0xb810
callq 0xbb40
callq 0xbd00
callq 0xc190
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x140, %rsp            # imm = 0x140
testb %al, %al
je 0xd31e
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)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x18e10
movq -0x110(%rbp), %rax
leaq 0x30769(%rip), %rcx     # 0x3dac8
movq %rcx, (%rax)
movl $0x0, 0x18(%rax)
movl $0x400, 0x1c(%rax)      # imm = 0x400
movl $0xa, 0x20(%rax)
movl $0x28, %edi
callq 0x7250
movq %rax, -0x108(%rbp)
jmp 0xd38a
movq -0x108(%rbp), %rdi
callq 0x16960
jmp 0xd398
movq -0x110(%rbp), %rax
movq -0x108(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x20(%rbp)
movq -0x110(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0xd472
movq -0x110(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x120(%rbp)
movl $0x28, %edi
callq 0x7250
movq %rax, -0x118(%rbp)
jmp 0xd3e9
movq -0x118(%rbp), %rdi
movq -0x110(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0xd220
jmp 0xd401
movq -0x118(%rbp), %rsi
movq -0x120(%rbp), %rdi
movq (%rdi), %rax
movq 0x58(%rax), %rax
callq *%rax
jmp 0xd41a
jmp 0xd41c
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xd3b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xd538
movq -0x108(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x7220
jmp 0xd538
movq -0x118(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x7220
jmp 0xd538
leaq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xd52f
leaq -0x40(%rbp), %rax
movq %rax, -0x130(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x124(%rbp)
cmpl $0x28, %eax
ja 0xd4e4
movq -0x130(%rbp), %rcx
movl -0x124(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x138(%rbp)
jmp 0xd501
movq -0x130(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x138(%rbp)
movq -0x110(%rbp), %rdi
movq -0x138(%rbp), %rax
movl (%rax), %esi
movq (%rdi), %rax
movq 0x98(%rax), %rax
callq *%rax
jmp 0xd51f
jmp 0xd521
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xd49d
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x110(%rbp), %rdi
callq 0x195c0
movq -0x18(%rbp), %rdi
callq 0x7370
nopl (%rax)
// File: yasz24[P]eau2/tests/./../src/store/../network/network.h
// Function: Message::Message(int, unsigned long, unsigned long, unsigned long)
Message(int kind, size_t sender, size_t target, size_t id) {
        kind_ = (enum MsgKind)kind;
        sender_ = sender;
        target_ = target;
        id_ = id;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x15470
movq -0x30(%rbp), %rax
leaq 0x3061d(%rip), %rcx     # 0x3dba0
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: yasz24[P]eau2/tests/./../src/store/../network/network.h
// Function: Status::Status(char*, unsigned long, unsigned long, unsigned long)
Status(char* status_msg, size_t sender, size_t target, size_t id) {
        kind_ = (MsgKind)6; 
        sender_ = sender;
        target_ = target;
        id_ = id;
        status_msg_ = status_msg;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1b7f0
movq -0x30(%rbp), %rax
leaq 0x2e56c(%rip), %rcx     # 0x3dde0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x6, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x249d
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2c90
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x2c90
movq %rax, %rcx
movl -0x20(%rbp), %eax
cmpl (%rcx), %eax
je 0x2487
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2c90
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x2c90
movq %rax, %rcx
movl -0x24(%rbp), %eax
subl (%rcx), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rdx
subl (%rdx), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
cmpl %ecx, %eax
jne 0x248d
movb $0x0, -0x1(%rbp)
jmp 0x24a1
jmp 0x248f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2407
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2cb0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x25b7
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2cb0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x2587
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x2c90
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl (%rcx), %eax
jne 0x253a
movq 0x7aac(%rip), %rdi      # 0x9fd8
leaq 0x3ad1(%rip), %rsi      # 0x6004
callq 0x2170
jmp 0x2577
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x2562
movq 0x7a84(%rip), %rdi      # 0x9fd8
leaq 0x3ab2(%rip), %rsi      # 0x600d
callq 0x2170
jmp 0x2575
movq 0x7a6f(%rip), %rdi      # 0x9fd8
leaq 0x3aa5(%rip), %rsi      # 0x6015
callq 0x2170
jmp 0x2577
jmp 0x2579
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x24eb
movq 0x7a4a(%rip), %rdi      # 0x9fd8
leaq 0x3a88(%rip), %rsi      # 0x601d
callq 0x2170
movq %rax, %rdi
movq 0x7a24(%rip), %rsi      # 0x9fc8
callq 0x2190
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x24c3
movq 0x7a1a(%rip), %rdi      # 0x9fd8
movq 0x7a03(%rip), %rsi      # 0x9fc8
callq 0x2190
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2cd0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x2689
movq 0x79cd(%rip), %rdi      # 0x9fd8
leaq 0x3a0f(%rip), %rsi      # 0x6021
callq 0x2170
movq %rax, %rdi
movl -0xc(%rbp), %esi
incl %esi
callq 0x2250
movq %rax, %rdi
movq 0x799a(%rip), %rsi      # 0x9fc8
callq 0x2190
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x2d00
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2d20
movq -0x48(%rbp), %rdi
callq 0x24b0
jmp 0x265b
leaq -0x28(%rbp), %rdi
callq 0x2e10
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x25e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2e10
jmp 0x268f
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2260
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2210
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x90(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x3430
movq -0x90(%rbp), %rdi
callq 0x3470
jmp 0x2bcb
leaq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x35f0
jmp 0x2bdd
leaq -0x70(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x26a0
jmp 0x2bef
movq 0x73e2(%rip), %rdi      # 0x9fd8
leaq -0x70(%rbp), %rsi
callq 0x2130
jmp 0x2c01
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x88(%rbp), %rdi
callq 0x3620
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3680
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2c6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2c63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x88(%rbp), %rdi
callq 0x3620
leaq -0x40(%rbp), %rdi
callq 0x3680
movq -0x48(%rbp), %rdi
callq 0x2260
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x3, 0x18(%rax)
jg 0x348f
jmp 0x35d2
movq -0x40(%rbp), %rdi
callq 0x3a80
movq -0x40(%rbp), %rax
movslq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
leaq -0x25(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3aa0
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rdx
callq 0x3ac0
jmp 0x34cf
leaq -0x25(%rbp), %rdi
callq 0x3b40
movl $0x0, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jl 0x35c9
jmp 0x34eb
movslq -0x38(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x33d0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movslq -0x38(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x33d0
movq -0x40(%rbp), %rdx
movl (%rax), %ecx
xorl %eax, %eax
cmpl 0x18(%rdx), %ecx
movb %al, -0x51(%rbp)
jge 0x352e
leaq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x23f0
xorb $-0x1, %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x34eb
movslq -0x38(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x33d0
movq -0x40(%rbp), %rcx
movl (%rax), %eax
cmpl 0x18(%rcx), %eax
jge 0x35bb
movq -0x40(%rbp), %rcx
movl -0x38(%rbp), %eax
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x359d
movq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3b60
jmp 0x356d
jmp 0x35b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x3b40
jmp 0x35d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2e10
jmp 0x35d8
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movslq -0x38(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x33d0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x35c4
movl -0x38(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x34df
leaq -0x20(%rbp), %rdi
callq 0x2e10
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2260
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x5470
movq -0x8(%rbp), %rdi
callq 0x5180
movq -0x260(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x5250
jmp 0x93b5
leaq -0x248(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x5580
movq -0x268(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x50b0
jmp 0x93dd
jmp 0x93df
leaq -0x218(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x50b0
movq %rax, -0x270(%rbp)
jmp 0x93fb
movq -0x270(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5500
movb %al, -0x271(%rbp)
jmp 0x9419
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x9425
jmp 0x9497
movq -0x10(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x98b0
movb %dl, -0x281(%rbp)
movq %rax, -0x280(%rbp)
jmp 0x9444
movb -0x281(%rbp), %al
movq -0x280(%rbp), %rcx
movq %rcx, -0x258(%rbp)
movb %al, -0x250(%rbp)
jmp 0x93df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x94c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x57a8
jmp 0x94c6
leaq -0x218(%rbp), %rdi
callq 0x50d0
jmp 0x94a5
leaq -0x248(%rbp), %rdi
callq 0x57a8
leaq -0x218(%rbp), %rdi
callq 0x5110
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x5110
movq -0x220(%rbp), %rdi
callq 0x5700
nop
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movl $0x30, %edi
callq 0x53c0
movq %rax, %rdi
movq %rdi, -0x60(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x51e0
movq -0x60(%rbp), %rdi
callq 0x9900
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x30, %edi
callq 0x53c0
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x51e0
movq -0x58(%rbp), %rdi
callq 0x9900
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9370
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x9370
movq -0x20(%rbp), %rdi
callq 0x9920
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9920
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
je 0x9598
movb $0x0, -0x11(%rbp)
jmp 0x9647
movq -0x20(%rbp), %rdi
callq 0x9940
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9940
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x99a0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9970
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x61(%rbp)
jne 0x95da
jmp 0x95f7
movq -0x20(%rbp), %rdi
callq 0x99a0
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x9970
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x9600
jmp 0x9645
leaq -0x38(%rbp), %rdi
callq 0x9a00
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9a00
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x99d0
testb $0x1, %al
jne 0x9628
jmp 0x962e
movb $0x0, -0x11(%rbp)
jmp 0x9645
leaq -0x38(%rbp), %rdi
callq 0x9a20
leaq -0x30(%rbp), %rdi
callq 0x9a20
jmp 0x95b2
jmp 0x9647
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x966c
movq -0x78(%rbp), %rdi
callq 0x9a50
movq -0x78(%rbp), %rdi
movl $0x30, %esi
callq 0x53d0
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x9691
movq -0x80(%rbp), %rdi
callq 0x9a50
movq -0x80(%rbp), %rdi
movl $0x30, %esi
callq 0x53d0
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x120(%rbp)
movq %rdi, %rax
movq %rax, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x2ad30
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x2e560
jmp 0x2a688
movq -0x28(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x2e590
jmp 0x2a69a
jmp 0x2a69c
leaq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2e5c0
movb %al, -0x121(%rbp)
jmp 0x2a6b4
movb -0x121(%rbp), %al
testb $0x1, %al
jne 0x2a713
jmp 0x2a6c0
leaq -0x98(%rbp), %rdi
callq 0x2e6d0
leaq -0x58(%rbp), %rdi
callq 0x2e6d0
jmp 0x2a768
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2a88c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2a75a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2e6d0
jmp 0x2a75a
leaq -0x58(%rbp), %rdi
callq 0x2e670
movq %rax, -0x130(%rbp)
jmp 0x2a725
movq -0x120(%rbp), %rdi
movq -0x130(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rsi
callq 0x2b1d0
jmp 0x2a748
jmp 0x2a74a
leaq -0x58(%rbp), %rdi
callq 0x2e690
jmp 0x2a755
jmp 0x2a69c
leaq -0x58(%rbp), %rdi
callq 0x2e6d0
jmp 0x2a88c
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x2e560
jmp 0x2a788
movq -0xa8(%rbp), %rsi
leaq -0x108(%rbp), %rdi
callq 0x2e590
jmp 0x2a79d
jmp 0x2a79f
leaq -0xd8(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x2e5c0
movb %al, -0x131(%rbp)
jmp 0x2a7ba
movb -0x131(%rbp), %al
testb $0x1, %al
jne 0x2a80b
jmp 0x2a7c6
leaq -0x108(%rbp), %rdi
callq 0x2e6d0
leaq -0xd8(%rbp), %rdi
callq 0x2e6d0
jmp 0x2a866
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2a858
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x2e6d0
jmp 0x2a858
leaq -0xd8(%rbp), %rdi
callq 0x2e670
movq %rax, -0x140(%rbp)
jmp 0x2a820
movq -0x120(%rbp), %rdi
movq -0x140(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x110(%rbp), %rsi
callq 0x2b1d0
jmp 0x2a843
jmp 0x2a845
leaq -0xd8(%rbp), %rdi
callq 0x2e690
jmp 0x2a853
jmp 0x2a79f
leaq -0xd8(%rbp), %rdi
callq 0x2e6d0
jmp 0x2a88c
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2a87c
movq -0x120(%rbp), %rdi
callq 0x2abe0
movq -0x118(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x120(%rbp), %rdi
callq 0x2abe0
movq -0x60(%rbp), %rdi
callq 0x84d0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movl $0x0, 0x54(%rsp)
movl %edi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
cmpl $0x2, 0x50(%rsp)
je 0x11a5b7
leaq 0x338f78(%rip), %rdi    # 0x45351b
movb $0x0, %al
callq 0x1130b0
movl $0x1, 0x54(%rsp)
jmp 0x11a646
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1136a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x11a860
jmp 0x11a5e8
leaq 0x27(%rsp), %rdi
callq 0x1137c0
leaq 0x28(%rsp), %rdi
callq 0x11a920
jmp 0x11a5fe
movl $0x0, 0x54(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1137d8
jmp 0x11a646
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x27(%rsp), %rdi
callq 0x1137c0
jmp 0x11a64f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1137d8
jmp 0x11a64f
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x1134a0
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x6680
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movl 0x38(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x38(%rsp)
cmpl $0x0, %eax
je 0x25ba
movq 0x8(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x38d0
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0x254f
movq 0xdaa8(%rip), %rax      # 0xffe0
movq (%rax), %rdi
movl 0x3c(%rsp), %edx
leaq 0x9abe(%rip), %rsi      # 0xc004
movb $0x0, %al
callq 0x2270
jmp 0x25ba
movl 0x3c(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x30(%rsp), %rdi
movl 0x18(%rsp), %esi
subl $0x1, %esi
callq 0x3960
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movl %eax, %edx
callq 0x3930
movl %eax, 0x3c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movb $0x2c, (%rax)
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x6680
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x2504
movq 0x20(%rsp), %rax
movb $0x0, (%rax)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)