LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../dataframe/../store/../utils/keyVal.h
// Function: KeyVal::deserialize(char*)
static KeyVal* deserialize(char* s) {
        Deserializable* ds = new Deserializable();
        char* key_serialized = JSONHelper::getValueFromKey("key_", s)->c_str();
        Object* key = ds->deserialize(key_serialized);
        Object* val = ds->deserialize(JSONHelper::getValueFromKey("val_", s)->c_str());
        KeyVal* kv = new KeyVal(key, val);
        return kv;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x37bb(%rip), %rdi      # 0x183f8
movq %rbx, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rsi
callq 0x12f4c
movq %rax, %r14
leaq 0x379d(%rip), %rdi      # 0x183fd
movq %rbx, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rsi
callq 0x12f4c
movq %rax, %rbx
pushq $0x20
popq %rdi
callq 0x7250
andq $0x0, 0x8(%rax)
leaq 0xecb8(%rip), %rcx      # 0x23948
movq %rcx, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../network/../store/value.h
// Function: Value::Value(char*)
Value(char* serialized) {
        Deserializable* ds = new Deserializable();
        char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
        char* serialData = JSONHelper::getValueFromKey("data", payload)->c_str();
        this->data = serialData;
        if(JSONHelper::isObject(serialData)) {
            this->data = ds->deserialize(JSONHelper::getValueFromKey("data", payload)->c_str())->serialize();
        } else {
            this->data = serialData;
        }
        this->length = std::stoi(JSONHelper::getValueFromKey("length", payload)->c_str());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rsi, %rdi
leaq 0xf031(%rip), %rax      # 0x23cf0
movq %rax, (%rbx)
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0x38be(%rip), %rdi      # 0x18598
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r15
movq %rax, 0x10(%rbx)
movq %rax, %rdi
callq 0xc2d4
testb %al, %al
je 0x14d2a
leaq 0x3893(%rip), %rdi      # 0x18598
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rsi
callq 0x12f4c
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq %rax, %r15
movq %r15, 0x10(%rbx)
leaq 0x3868(%rip), %rdi      # 0x1859d
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %r14
leaq -0x19(%rbp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x70f0
pushq $0xa
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x18(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7120
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x7120
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../network/network.h
// Function: Message::Message(char*)
Message(char* s) {
        char* payload = JSONHelper::getPayloadValue(s)->c_str();
        kind_ = (enum MsgKind)std::stoi(JSONHelper::getValueFromKey("kind_", payload)->c_str());
        sender_ = std::stoi(JSONHelper::getValueFromKey("sender_", payload)->c_str());
        target_ = std::stoi(JSONHelper::getValueFromKey("target_", payload)->c_str());
        id_ = std::stoi(JSONHelper::getValueFromKey("id_", payload)->c_str());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rsi, %rdi
leaq 0xfd7f(%rip), %rax      # 0x24c98
movq %rax, (%rbx)
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0x3342(%rip), %rdi      # 0x18276
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x38(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
movl %eax, 0x10(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x7120
leaq 0x3306(%rip), %rdi      # 0x1827c
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x38(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x18(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x7120
leaq 0x32c9(%rip), %rdi      # 0x18284
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x38(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x20(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x7120
leaq 0x35c7(%rip), %rdi      # 0x185c7
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x38(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x28(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x7120
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x15053
jmp 0x15069
jmp 0x15053
jmp 0x15069
jmp 0x15053
jmp 0x15069
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x7120
jmp 0x1506c
jmp 0x15069
jmp 0x15069
jmp 0x15069
jmp 0x15069
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../network/network.h
// Function: Put::Put(char*)
Put(char* s) {
        char* payload = JSONHelper::getPayloadValue(s)->c_str();
        kind_ = (enum MsgKind)std::stoi(JSONHelper::getValueFromKey("kind_", payload)->c_str());
        sender_ = std::stoi(JSONHelper::getValueFromKey("sender_", payload)->c_str());
        target_ = std::stoi(JSONHelper::getValueFromKey("target_", payload)->c_str());
        id_ = std::stoi(JSONHelper::getValueFromKey("id_", payload)->c_str());
        key_ = new Key(JSONHelper::getValueFromKey("key_", payload)->c_str());
        value_ = new Value(JSONHelper::getValueFromKey("value_", payload)->c_str()); 
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rsi, %rdi
leaq 0xf67d(%rip), %rax      # 0x24a00
movq %rax, (%rbx)
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0x2ed8(%rip), %rdi      # 0x18276
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
movl %eax, 0x10(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x2e9c(%rip), %rdi      # 0x1827c
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x18(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x2e5f(%rip), %rdi      # 0x18284
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x20(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x315d(%rip), %rdi      # 0x185c7
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x28(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7120
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r15
leaq 0x2f3e(%rip), %rdi      # 0x183f8
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x14b4e
movq %r15, 0x30(%rbx)
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r15
leaq 0x33f2(%rip), %rdi      # 0x188de
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x14ca0
movq %r15, 0x38(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15523
jmp 0x15539
jmp 0x15523
jmp 0x15539
jmp 0x15523
jmp 0x15539
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x7120
jmp 0x1554b
jmp 0x15539
jmp 0x15539
jmp 0x15539
jmp 0x15539
movq %rax, %rbx
jmp 0x1554b
jmp 0x15540
movq %rax, %rbx
movq %r15, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../network/network.h
// Function: Get::Get(char*)
Get(char* s) {
        char* payload = JSONHelper::getPayloadValue(s)->c_str();
        kind_ = (enum MsgKind)std::stoi(JSONHelper::getValueFromKey("kind_", payload)->c_str());
        sender_ = std::stoi(JSONHelper::getValueFromKey("sender_", payload)->c_str());
        target_ = std::stoi(JSONHelper::getValueFromKey("target_", payload)->c_str());
        id_ = std::stoi(JSONHelper::getValueFromKey("id_", payload)->c_str());
        key_ = new Key(JSONHelper::getValueFromKey("key_", payload)->c_str());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rsi, %rdi
leaq 0xe53d(%rip), %rax      # 0x23c88
movq %rax, (%rbx)
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0x2b10(%rip), %rdi      # 0x18276
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
movl %eax, 0x10(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x2ad4(%rip), %rdi      # 0x1827c
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x18(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x2a97(%rip), %rdi      # 0x18284
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x20(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x2d95(%rip), %rdi      # 0x185c7
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x28(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7120
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r15
leaq 0x2b76(%rip), %rdi      # 0x183f8
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x14b4e
movq %r15, 0x30(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x158b9
jmp 0x158cf
jmp 0x158b9
jmp 0x158cf
jmp 0x158b9
jmp 0x158cf
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x7120
jmp 0x158d2
jmp 0x158cf
jmp 0x158cf
jmp 0x158cf
jmp 0x158cf
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7390
movq %rax, %rbx
movq %r15, %rdi
callq 0x7220
jmp 0x158d2
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../network/network.h
// Function: Status::Status(char*)
Status(char* s) {
        char* payload = JSONHelper::getPayloadValue(s)->c_str();
        kind_ = (enum MsgKind)std::stoi(JSONHelper::getValueFromKey("kind_", payload)->c_str());
        sender_ = std::stoi(JSONHelper::getValueFromKey("sender_", payload)->c_str());
        target_ = std::stoi(JSONHelper::getValueFromKey("target_", payload)->c_str());
        id_ = std::stoi(JSONHelper::getValueFromKey("id_", payload)->c_str());
        status_msg_ = JSONHelper::getValueFromKey("status_msg_", payload)->c_str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rsi, %rdi
leaq 0xf227(%rip), %rax      # 0x24ce8
movq %rax, (%rbx)
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0x279a(%rip), %rdi      # 0x18276
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x38(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
movl %eax, 0x10(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x7120
leaq 0x275e(%rip), %rdi      # 0x1827c
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x38(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x18(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x7120
leaq 0x2721(%rip), %rdi      # 0x18284
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x38(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x20(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x7120
leaq 0x2a1f(%rip), %rdi      # 0x185c7
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x38(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x28(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x7120
leaq 0x3394(%rip), %rdi      # 0x18f81
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, 0x30(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x15c17
jmp 0x15c2d
jmp 0x15c17
jmp 0x15c2d
jmp 0x15c17
jmp 0x15c2d
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x7120
jmp 0x15c30
jmp 0x15c2d
jmp 0x15c2d
jmp 0x15c2d
jmp 0x15c2d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../dataframe/../store/../utils/array.h
// Function: Array::Array(char*, KVStore*)
Array(char* serialized, KVStore* kv) {
        Deserializable* ds = new Deserializable();
        char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
        arraySize_ = std::stoi(JSONHelper::getValueFromKey("arraySize_", payload)->c_str());
        int len = std::stoi(JSONHelper::getValueFromKey("listLength_", payload)->c_str());
        this->listLength_ = len;

        char* vals = JSONHelper::getValueFromKey("objs_", payload)->c_str();
        Array* temp = new Array(len);
        for(int i = 0; i < len; i++) {
            char* serial = JSONHelper::getArrayValueAt(vals, i)->c_str();
            //std::cout<<serial<<"\n";
            Object* o = ds->deserialize(serial, kv);
            temp->pushBack(o);
        }
        //delete temp;
        this->objs_ = temp->objs_;
        delete ds;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r13
andq $0x0, 0x8(%rdi)
movq %rdx, %r14
movq %rsi, %rdi
leaq 0xd5e8(%rip), %rax      # 0x23708
movq %rax, (%r13)
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r15
leaq 0x222d(%rip), %rdi      # 0x18369
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x58(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x20(%r13)
leaq -0x58(%rbp), %rdi
callq 0x7120
leaq 0x22ea(%rip), %rdi      # 0x1846b
movq %r15, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x58(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
movl %eax, %r12d
leaq -0x58(%rbp), %rdi
callq 0x7120
movslq %r12d, %rbx
movq %r13, -0x38(%rbp)
movq %rbx, 0x18(%r13)
leaq 0x21a6(%rip), %rdi      # 0x18374
movq %r15, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r13
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x9c9c
xorl %ebx, %ebx
testl %r12d, %r12d
cmovlel %ebx, %r12d
cmpl %ebx, %r12d
je 0x16234
movq %r13, %rdi
movl %ebx, %esi
callq 0xc4c8
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rsi
movq %r14, %rdx
callq 0x1358a
movq (%r15), %rcx
movq %r15, %rdi
movq %rax, %rsi
callq *0x58(%rcx)
incl %ebx
jmp 0x16201
movq 0x10(%r15), %rax
movq -0x38(%rbp), %rcx
movq %rax, 0x10(%rcx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x7220
jmp 0x16275
jmp 0x16260
jmp 0x16272
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x7120
jmp 0x16275
jmp 0x16272
jmp 0x16272
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::DistributedDataFrame(char*, KVStore*)
DistributedDataFrame(char* serialized, KVStore* kv) {
      Deserializable* d = new Deserializable();
      char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
      Schema* sch = new Schema(JSONHelper::getValueFromKey("schema_", payload)->c_str());
      Array* cols = new Array(JSONHelper::getValueFromKey("cols_", payload)->c_str(), kv);
      this->kv_ = kv;
      this->schema_ = sch;
      this->cols_ = cols;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rdx, %r14
movq %rsi, %rdi
leaq 0xceaf(%rip), %rax      # 0x23ec0
movq %rax, (%rbx)
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r12
pushq $0x50
popq %rdi
callq 0x7250
movq %rax, %r15
leaq 0x186e(%rip), %rdi      # 0x188a5
movq %r12, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x145a2
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r13
leaq 0x1848(%rip), %rdi      # 0x188ad
movq %r12, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %r13, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x160fa
movq %r14, 0x20(%rbx)
movq %r15, 0x10(%rbx)
movq %r13, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r13, %r15
jmp 0x170aa
movq %rax, %rbx
movq %r15, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../dataframe/dataframe.h
// Function: DataFrame::equals(Object*)
bool equals(Object  * other) {
      if (other == this) return true;
        DataFrame* x = dynamic_cast<DataFrame*>(other);
        if (x == nullptr) return false;
        if (this->ncols() != x->ncols()) return false;
        if (this->nrows() != x->nrows()) return false;
        for (size_t i = 0; i < this->ncols(); i++) {
            if (!(this->cols_->get(i)->equals(x->cols_->get(i)))) { 
                return false; 
            }
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %rdi, %rsi
je 0x17800
testq %rsi, %rsi
je 0x177fb
movq %rdi, %rbx
leaq 0xbb2c(%rip), %rax      # 0x232a8
leaq 0xd49d(%rip), %rdx      # 0x24c20
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0x17803
movq %rax, %r15
movq 0x10(%rbx), %rax
movq 0x20(%rax), %rdx
movq 0x10(%r15), %rcx
cmpq 0x20(%rcx), %rdx
jne 0x177fb
movq 0x28(%rax), %rax
cmpq 0x28(%rcx), %rax
jne 0x177fb
xorl %r12d, %r12d
movq 0x10(%rbx), %rax
cmpq 0x20(%rax), %r12
setae %r14b
jae 0x17803
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
movq %rax, %r13
movq 0x18(%r15), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
movq (%r13), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
incq %r12
testb %al, %al
jne 0x177ba
jmp 0x17803
xorl %r14d, %r14d
jmp 0x17803
movb $0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../dataframe/dataframe.h
// Function: DataFrame::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("DataFrame");
        char * serializedschema = schema_->serialize();
        sb->write("schema_", serializedschema);
        char * seralizedcols = cols_->serialize();
        sb->write("cols_", seralizedcols);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
     }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0x1061(%rip), %rsi      # 0x1889b
movq %rbx, %rdi
callq 0x7fd8
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x1052(%rip), %rsi      # 0x188a5
movq %rbx, %rdi
movq %rax, %rdx
callq 0x844c
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x103e(%rip), %rsi      # 0x188ad
movq %rbx, %rdi
movq %rax, %rdx
callq 0x844c
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1789b
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../network/network.h
// Function: Status::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Status");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        sb->write("status_msg_", status_msg_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0x154e(%rip), %rsi      # 0x18f00
movq %rbx, %rdi
callq 0x7fd8
movl 0x10(%r14), %edx
leaq 0x8b1(%rip), %rsi       # 0x18276
movq %rbx, %rdi
callq 0x801c
movq 0x18(%r14), %rdx
leaq 0x8a4(%rip), %rsi       # 0x1827c
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0x899(%rip), %rsi       # 0x18284
movq %rbx, %rdi
callq 0x8062
movq 0x28(%r14), %rdx
leaq 0xbc9(%rip), %rsi       # 0x185c7
movq %rbx, %rdi
callq 0x8062
movq 0x30(%r14), %rdx
leaq 0x1570(%rip), %rsi      # 0x18f81
movq %rbx, %rdi
callq 0x844c
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17a3a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/jsonHelper.h
// Function: JSONHelper::arrayLen(char*)
static int arrayLen(char* s) {
        int len = strlen( s );
        bool valuesFound = false;
        char objStart = '{';
        char objEnd = '}';
        int count = 0;
        int startCharDepth = -1;
        //pull the top level object-value from the serialzed string
        for (int i = 0; i < len; i++){
            char temp = s[i];
            if(!valuesFound) {
                //the three ways a payload in our JSON can start, will rely on this to know what character closes the value
                //also keeps track of depth if there are nested objects
                if(temp == '{' || temp == '[' || temp == '\'') {
                    objStart = temp;
                    startCharDepth = 1;
                    valuesFound = true;
                    if(temp == '{') {
                        objEnd = '}';
                    } else if(temp == '[') {
                        objEnd = ']';
                    } else if(temp == '\'') {
                        objEnd = '\'';
                        startCharDepth = 0;
                    }   
                }
            } else if(temp == objStart) {
                startCharDepth++;
            } 
            if(temp == objEnd && valuesFound) {
                if(temp != objStart) {
                    startCharDepth--;
                }
                //if we've reached the final level of end character, break out of loop
                if(startCharDepth <= 0  || (temp == objStart && startCharDepth % 2 == 0)) {
                    count++;
                }
            }
        }
        return count;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x7110
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
pushq $-0x1
popq %r9
movb $0x7d, %dil
movb $0x7b, %r8b
pushq $0x1
popq %rsi
xorl %ecx, %ecx
xorl %r10d, %r10d
cmpq %rdx, %rax
je 0x17b05
movb (%rbx,%rdx), %r11b
testb $0x1, %r10b
je 0x17aa9
xorl %r14d, %r14d
cmpb %r8b, %r11b
sete %r14b
addl %r14d, %r9d
cmpb %dil, %r11b
je 0x17ade
jmp 0x17b00
movzbl %r11b, %r14d
cmpl $0x27, %r14d
je 0x17ad2
cmpl $0x7b, %r14d
je 0x17ac4
cmpl $0x5b, %r14d
jne 0x17b00
movb $0x5d, %dil
jmp 0x17ac7
movb $0x7d, %dil
movb $0x1, %r10b
movl %r11d, %r8d
movl %esi, %r9d
jmp 0x17b00
xorl %r9d, %r9d
movl %r11d, %r8d
movl %r11d, %edi
movb $0x1, %r10b
xorl %r14d, %r14d
cmpb %r8b, %r11b
setne %r14b
subl %r14d, %r9d
testl %r9d, %r9d
jle 0x17afe
cmpb %r8b, %r11b
jne 0x17b00
movl %r9d, %r11d
andl $0x1, %r11d
jne 0x17b00
incl %ecx
incq %rdx
jmp 0x17a86
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../network/network.h
// Function: Directory::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Directory");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        sb->write("ports", ports, clients);
        sb->write("clients", clients);
        sb->write("addresses", addresses, clients);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0x13cd(%rip), %rsi      # 0x18f07
movq %rbx, %rdi
callq 0x7fd8
movl 0x10(%r14), %edx
leaq 0x729(%rip), %rsi       # 0x18276
movq %rbx, %rdi
callq 0x801c
movq 0x18(%r14), %rdx
leaq 0x71c(%rip), %rsi       # 0x1827c
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0x711(%rip), %rsi       # 0x18284
movq %rbx, %rdi
callq 0x8062
movq 0x28(%r14), %rdx
leaq 0xa41(%rip), %rsi       # 0x185c7
movq %rbx, %rdi
callq 0x8062
movq 0x38(%r14), %rdx
movl 0x30(%r14), %ecx
leaq 0x13f8(%rip), %rsi      # 0x18f95
movq %rbx, %rdi
callq 0x17c14
movq 0x30(%r14), %rdx
leaq 0x13dd(%rip), %rsi      # 0x18f8d
movq %rbx, %rdi
callq 0x8062
movq 0x40(%r14), %rdx
movl 0x30(%r14), %ecx
leaq 0x13d4(%rip), %rsi      # 0x18f9b
movq %rbx, %rdi
callq 0xea86
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17bf0
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../network/../serialize/serial.h
// Function: Serializable::write(char const*, unsigned long*, int)
void write(const char* name, size_t* val, int len) {
        char str[1000];
        sprintf(str, "'%s' : [ ", name);
        buff->c(str);
        for(int i = 0; i < len; i++) {
            sprintf(str, "'%zu',", val[i]);
            buff->c(str);
        }
        buff->c("], ");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3e8, %rsp            # imm = 0x3E8
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r15
leaq 0x740(%rip), %rsi       # 0x1837a
xorl %r13d, %r13d
leaq -0x410(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x7080
movq (%r15), %rdi
movq %r12, %rsi
callq 0x8114
testl %ebx, %ebx
cmovlel %r13d, %ebx
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x17c8c
movq (%r14,%r13,8), %rdx
movq %r12, %rdi
leaq 0x1330(%rip), %rsi      # 0x18fa5
xorl %eax, %eax
callq 0x7080
movq (%r15), %rdi
movq %r12, %rsi
callq 0x8114
incq %r13
jmp 0x17c62
movq (%r15), %rdi
leaq 0x6f2(%rip), %rsi       # 0x18388
callq 0x8114
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/vector_list/bench.cpp
// Function: bench_emplace_back<Trivial<8>>::run()
static void run(){
        new_graph<T>("emplace_back", "us");

        auto sizes = { 100000, 200000, 300000, 400000, 500000, 600000, 700000, 800000, 900000, 1000000 };
        bench<std::vector<T>, microseconds, Empty, EmplaceBack>("vector", sizes);
        bench<std::list<T>,   microseconds, Empty, EmplaceBack>("list",   sizes);
        bench<std::deque<T>,  microseconds, Empty, EmplaceBack>("deque",  sizes);
    }

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0x377ed(%rip), %rsi     # 0x45a79
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x3080
leaq 0x37728(%rip), %rsi     # 0x459ca
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4b9a
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b0
vmovups 0x37649(%rip), %ymm0    # 0x45928
movabsq $0xf4240000dbba0, %rax  # imm = 0xF4240000DBBA0
movq %rbx, 0x30(%rsp)
movq $0xa, 0x38(%rsp)
movq %rax, 0x20(%rbx)
vmovups %ymm0, (%rbx)
leaq 0x376c7(%rip), %rsi     # 0x459cd
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
vzeroupper
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xe3de
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x3769c(%rip), %rsi     # 0x459d4
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xe4d6
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x37672(%rip), %rsi     # 0x459d9
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xe5cc
leaq 0x10(%rsp), %rdi
callq 0x30b0
addq $0x70, %rsp
popq %rbx
retq
jmp 0xe39d
jmp 0xe3c7
jmp 0xe39d
jmp 0xe3c7
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
jmp 0xe3c0
jmp 0xe3c7
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x30b0
jmp 0xe3bb
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x30b0
jmp 0xe3ca
movq %rax, %rbx
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/vector_list/bench.cpp
// Function: bench_fill_front<Trivial<8>>::run()
static void run(){
        new_graph<T>("fill_front", "us");

        auto sizes = { 10000, 20000, 30000, 40000, 50000, 60000, 70000, 80000, 90000, 100000 };

        // it is too slow with bigger data types
        if(is_small<T>()){
            bench<std::vector<T>, microseconds, Empty, FillFront>("vector", sizes);
        }

        bench<std::list<T>,   microseconds, Empty, FillFront>("list",   sizes);
        bench<std::deque<T>,  microseconds, Empty, FillFront>("deque",  sizes);
    }

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0x340f6(%rip), %rsi     # 0x45a86
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x3080
leaq 0x34024(%rip), %rsi     # 0x459ca
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4b9a
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b0
vmovups 0x33f6d(%rip), %ymm0    # 0x45950
movabsq $0x186a000015f90, %rax  # imm = 0x186A000015F90
movq %rbx, 0x30(%rsp)
movq $0xa, 0x38(%rsp)
movq %rax, 0x20(%rbx)
vmovups %ymm0, (%rbx)
leaq 0x33fc3(%rip), %rsi     # 0x459cd
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
vzeroupper
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x11ae2
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x33f98(%rip), %rsi     # 0x459d4
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x11bda
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x33f6e(%rip), %rsi     # 0x459d9
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x11cd0
leaq 0x10(%rsp), %rdi
callq 0x30b0
addq $0x70, %rsp
popq %rbx
retq
jmp 0x11aa1
jmp 0x11acb
jmp 0x11aa1
jmp 0x11acb
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
jmp 0x11ac4
jmp 0x11acb
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x30b0
jmp 0x11abf
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x30b0
jmp 0x11ace
movq %rax, %rbx
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/vector_list/bench.cpp
// Function: bench_linear_search<Trivial<8>>::run()
static void run(){
        new_graph<T>("linear_search", "us");

        auto sizes = {1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000};
        bench<std::vector<T>, microseconds, FilledRandom, Find>("vector", sizes);
        bench<std::list<T>,   microseconds, FilledRandom, Find>("list",   sizes);
        bench<std::deque<T>,  microseconds, FilledRandom, Find>("deque",  sizes);
    }

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0x2f76f(%rip), %rsi     # 0x45a9f
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x3080
leaq 0x2f684(%rip), %rsi     # 0x459ca
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4b9a
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b0
vmovups 0x2f57d(%rip), %ymm0    # 0x45900
movabsq $0x271000002328, %rax   # imm = 0x271000002328
movq %rbx, 0x30(%rsp)
movq $0xa, 0x38(%rsp)
movq %rax, 0x20(%rbx)
vmovups %ymm0, (%rbx)
leaq 0x2f623(%rip), %rsi     # 0x459cd
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
vzeroupper
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x16482
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x2f5f8(%rip), %rsi     # 0x459d4
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x16575
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x2f5ce(%rip), %rsi     # 0x459d9
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x16668
leaq 0x10(%rsp), %rdi
callq 0x30b0
addq $0x70, %rsp
popq %rbx
retq
jmp 0x16441
jmp 0x1646b
jmp 0x16441
jmp 0x1646b
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
jmp 0x16464
jmp 0x1646b
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x30b0
jmp 0x1645f
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x30b0
jmp 0x1646e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/vector_list/bench.cpp
// Function: bench_random_remove<Trivial<8>>::run()
static void run(){
        new_graph<T>("random_remove", "ms");

        auto sizes = {10000, 20000, 30000, 40000, 50000, 60000, 70000, 80000, 90000, 100000};
        bench<std::vector<T>, milliseconds, FilledRandom, Erase>("vector", sizes);
        bench<std::list<T>,   milliseconds, FilledRandom, Erase>("list",   sizes);
        bench<std::deque<T>,  milliseconds, FilledRandom, Erase>("deque",  sizes);
        bench<std::vector<T>, milliseconds, FilledRandom, RemoveErase>("vector_rem", sizes);
    }

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0x1e0ad(%rip), %rsi     # 0x45b31
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x3080
leaq 0x1e094(%rip), %rsi     # 0x45b2e
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4b9a
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b0
vmovups 0x1de79(%rip), %ymm0    # 0x45950
movabsq $0x186a000015f90, %rax  # imm = 0x186A000015F90
movq %rbx, 0x30(%rsp)
movq $0xa, 0x38(%rsp)
movq %rax, 0x20(%rbx)
vmovups %ymm0, (%rbx)
leaq 0x1decf(%rip), %rsi     # 0x459cd
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
vzeroupper
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x27c09
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x1dea4(%rip), %rsi     # 0x459d4
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x27cfc
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x1de7a(%rip), %rsi     # 0x459d9
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x27def
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x1dfb1(%rip), %rsi     # 0x45b3f
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x27ee2
leaq 0x10(%rsp), %rdi
callq 0x30b0
addq $0x70, %rsp
popq %rbx
retq
jmp 0x27bc8
jmp 0x27bf2
jmp 0x27bc8
jmp 0x27bf2
jmp 0x27bc8
jmp 0x27bf2
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
jmp 0x27beb
jmp 0x27bf2
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x30b0
jmp 0x27be6
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x30b0
jmp 0x27bf5
movq %rax, %rbx
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/vector_list/bench.cpp
// Function: bench_sort<Trivial<8>>::run()
static void run(){
        new_graph<T>("sort", "ms");

        auto sizes = {100000, 200000, 300000, 400000, 500000, 600000, 700000, 800000, 900000, 1000000};
        bench<std::vector<T>, milliseconds, FilledRandom, Sort>("vector", sizes);
        bench<std::list<T>,   milliseconds, FilledRandom, Sort>("list",   sizes);
        bench<std::deque<T>,  milliseconds, FilledRandom, Sort>("deque",  sizes);
    }

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0x1787e(%rip), %rsi     # 0x45b4a
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x3080
leaq 0x1784c(%rip), %rsi     # 0x45b2e
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4b9a
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b0
vmovups 0x17609(%rip), %ymm0    # 0x45928
movabsq $0xf4240000dbba0, %rax  # imm = 0xF4240000DBBA0
movq %rbx, 0x30(%rsp)
movq $0xa, 0x38(%rsp)
movq %rax, 0x20(%rbx)
vmovups %ymm0, (%rbx)
leaq 0x17687(%rip), %rsi     # 0x459cd
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
vzeroupper
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2e41e
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x1765c(%rip), %rsi     # 0x459d4
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2e515
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x17632(%rip), %rsi     # 0x459d9
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2e601
leaq 0x10(%rsp), %rdi
callq 0x30b0
addq $0x70, %rsp
popq %rbx
retq
jmp 0x2e3dd
jmp 0x2e407
jmp 0x2e3dd
jmp 0x2e407
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
jmp 0x2e400
jmp 0x2e407
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x30b0
jmp 0x2e3fb
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x30b0
jmp 0x2e40a
movq %rax, %rbx
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/vector_list/bench.cpp
// Function: bench_destruction<Trivial<8>>::run()
static void run(){
        new_graph<T>("destruction", "us");

        auto sizes = {100000, 200000, 300000, 400000, 500000, 600000, 700000, 800000, 900000, 1000000};
        bench<std::vector<T>, microseconds, SmartFilled, SmartDelete>("vector", sizes);
        bench<std::list<T>,   microseconds, SmartFilled, SmartDelete>("list",   sizes);
        bench<std::deque<T>,  microseconds, SmartFilled, SmartDelete>("deque",  sizes);
    }

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0x9c71(%rip), %rsi      # 0x45b4f
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x3080
leaq 0x9ad6(%rip), %rsi      # 0x459ca
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4b9a
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b0
vmovups 0x99f7(%rip), %ymm0     # 0x45928
movabsq $0xf4240000dbba0, %rax  # imm = 0xF4240000DBBA0
movq %rbx, 0x30(%rsp)
movq $0xa, 0x38(%rsp)
movq %rax, 0x20(%rbx)
vmovups %ymm0, (%rbx)
leaq 0x9a75(%rip), %rsi      # 0x459cd
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
vzeroupper
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3c030
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x9a4a(%rip), %rsi      # 0x459d4
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3c10e
leaq 0x10(%rsp), %rdi
callq 0x30b0
leaq 0x9a20(%rip), %rsi      # 0x459d9
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3c1ec
leaq 0x10(%rsp), %rdi
callq 0x30b0
addq $0x70, %rsp
popq %rbx
retq
jmp 0x3bfef
jmp 0x3c019
jmp 0x3bfef
jmp 0x3c019
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
jmp 0x3c012
jmp 0x3c019
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x30b0
jmp 0x3c00d
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x30b0
jmp 0x3c01c
movq %rax, %rbx
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/usingDirective.cc
// Function: main
int main() 
{
    // using directive; 
	// the names in blip are ``added'' to the global scope
    using namespace blip; // clash between ::j and blip::j
                          // detected only if j is used

    ++i;        // sets blip::i to 17
    ++::j;      // ok: sets global j to 1
    ++blip::j;  // ok: sets blip::j to 16

    int k = 97; // local k hides blip::k
    ++k;        // sets local k to 98

	::f();        
	blip::f();
	cout << "j: " << ::j << " k: " << k << endl; 

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
incl 0x2ddb(%rip)            # 0x4054
incl 0x2ded(%rip)            # 0x406c
incl 0x2dd3(%rip)            # 0x4058
callq 0x11bc
callq 0x1207
movq 0x2d42(%rip), %rdi      # 0x3fd8
leaq 0xd6c(%rip), %rsi       # 0x2009
callq 0x1050
movl 0x2dc4(%rip), %esi      # 0x406c
movq %rax, %rdi
callq 0x1070
leaq 0xd56(%rip), %rsi       # 0x200d
movq %rax, %rdi
callq 0x1050
pushq $0x62
popq %rsi
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/giovifazi[P]knossos-bloodbath/Map.cpp
// Function: Map::init(int)
void Map::init(int playerNum)
{
  // inizializza la lista delle ordinate per la matrice
  origin = new listaY;
  origin->down = NULL;

  // inizializza la lista delle ascisse
  origin->h = new listaX;
  origin->h->next = NULL;
  origin->h->val = playerNum;

  // inizializza le coordinate del nodo più in alto a sx
  mostUp = 0;
  mostLeft = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x2130
movq %rax, %r15
movq %rax, (%r14)
andq $0x0, (%rax)
pushq $0x18
popq %rdi
callq 0x2130
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%r15)
andq $0x0, (%rax)
movl %ebx, 0x8(%rax)
andq $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/giovifazi[P]knossos-bloodbath/Map.cpp
// Function: Map::draw_search()
void Map::draw_search()
{
  // Crea due puntatori che iterano per la matrice
  listaY* ordi = origin;
  listaX* asci;

  while(ordi != NULL)
  {
    asci = ordi->h;

    while(asci != NULL)
    {
      // in base al valore nella ascissa disegna cose diverse
      std::cout << asci->val;

      // scorre alla ascissa successiva
      asci = asci->next;
    }

    // Se il ciclo arriva qui, significa che ha finito una riga
    std::cout << "\n";
    ordi = ordi->down;    // passo alla riga successiva
  }

  //////////////////////////////////////////////
  //DEBUG STUFF
  std::cout << "Top left coordinate";
  std::cout << "(" << mostLeft << ", " << mostUp << ")\n";
  std::cout << "width = " << width << "\nheight = " << height << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xcc5e(%rip), %r14      # 0xffd0
leaq 0x94dc(%rip), %r15      # 0xc855
movq %rdi, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x33ae
leaq 0x8(%r12), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x33a1
movl 0x8(%r13), %esi
movq %r14, %rdi
callq 0x2210
jmp 0x338a
movq %r14, %rdi
movq %r15, %rsi
callq 0x2120
jmp 0x337c
movq 0xcc1b(%rip), %r14      # 0xffd0
leaq 0x4d24(%rip), %rsi      # 0x80e0
movq %r14, %rdi
callq 0x2120
leaq 0x4d29(%rip), %rsi      # 0x80f4
movq %r14, %rdi
callq 0x2120
movl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0x2210
leaq 0x4d11(%rip), %rsi      # 0x80f6
movq %rax, %rdi
callq 0x2120
movl 0x14(%rbx), %esi
movq %rax, %rdi
callq 0x2210
leaq 0x57d3(%rip), %rsi      # 0x8bd2
movq %rax, %rdi
callq 0x2120
leaq 0x4ceb(%rip), %rsi      # 0x80f9
movq %r14, %rdi
callq 0x2120
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x2210
leaq 0x4cda(%rip), %rsi      # 0x8102
movq %rax, %rdi
callq 0x2120
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O2/giovifazi[P]knossos-bloodbath/Map.cpp
// Function: Map::addColumn(bool)
void Map::addColumn(bool onTop)
{
  // aumento la larghezza della mappa
  width++;

  // creo un iteratore per la listaY
  listaY *itery = origin;

  if (onTop)
  {
    // Aggiorna il valore mostLeft
    mostLeft--;

    // Fa un head insert per ogni nodo listaY
    while (itery != NULL)
    {
      listaX *old_head = itery->h;    // salvo la vecchia testa
      itery->h = new listaX;          // creo un nuovo nodo
      itery->h->val = 0;              // gli metto valore 0
	   itery->h->pres = 0;             // imposto 0 giocatori nel nodo
      itery->h->next = old_head;      // lo collego al resto della lista

      itery = itery->down;            // itero in avanti
    }
  }
  else  // If (onTop == false)
  {
    listaX *iterx;

    while (itery != NULL)
    {
      iterx = itery->h;

      // faccio scorrere iterx alla fine della listaX
      if (iterx->next != NULL)
        while (iterx->next != NULL)
          iterx = iterx->next;

      iterx->next = new listaX;
      iterx->next->val = 0;
      iterx->next->pres = 0;
      iterx->next->next = NULL;

      itery = itery->down;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
incl 0x8(%rdi)
movq (%rdi), %r14
testl %esi, %esi
je 0x36e6
decl 0x10(%rdi)
pushq $0x18
popq %rbx
testq %r14, %r14
je 0x3727
movq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0x2130
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
andq $0x0, 0x8(%rax)
movq %r15, (%rax)
movq (%r14), %r14
jmp 0x36c0
pushq $0x18
popq %rbx
testq %r14, %r14
je 0x3727
movq 0x8(%r14), %rax
movq (%rax), %rcx
movq %rax, %r15
testq %rcx, %rcx
jne 0x3705
jmp 0x370d
movq %rcx, %rax
movq (%rcx), %rcx
movq %rax, %r15
testq %rcx, %rcx
jne 0x36ff
movq %rbx, %rdi
callq 0x2130
movb $0x0, 0x10(%rax)
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq (%r14), %r14
jmp 0x36e9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq