LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: coduin[P]epiphany-bin-info/epiphany-bin-info.cpp
// Function: parseSections(Elf32_Shdr*, unsigned long, char const*, unsigned long)
void parseSections(Elf32_Shdr* shdr, size_t count, const char* strtab,
                   size_t strsize) {
    if (showSections) {
        cout << "\nSection table (linker info):\n";
        cout << "ADDR        SIZE        NAME\n";
        for (size_t i = 0; i < count; i++) {
            if (shdr[i].sh_flags & SHF_ALLOC) {
                cout << addr(shdr[i].sh_addr);
            } else {
                cout << "          ";
            }
            cout << "  " << ashex(shdr[i].sh_size);
            if (shdr[i].sh_name != SHN_UNDEF && shdr[i].sh_name < strsize)
                cout << "  " << (&strtab[shdr[i].sh_name]);
            cout << endl;
        }
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
testb $0x1, 0x83d4(%rip)      # 0xb223
je 0x3010
movq 0x8174(%rip), %rdi      # 0xafd0
leaq 0x5274(%rip), %rsi      # 0x80d7
callq 0x21d0
movq 0x8161(%rip), %rdi      # 0xafd0
leaq 0x5280(%rip), %rsi      # 0x80f6
callq 0x21d0
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x300e
movq 0x50(%rsp), %rax
imulq $0x28, 0x30(%rsp), %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2f0a
movq 0x50(%rsp), %rax
movq 0x30(%rsp), %rcx
leaq (%rcx,%rcx,4), %rcx
movl 0xc(%rax,%rcx,8), %esi
leaq 0x2c(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4750
movq 0x10(%rsp), %rsi
movq 0x80f6(%rip), %rdi      # 0xafd0
callq 0x2680
jmp 0x2ee1
leaq 0x2c(%rsp), %rdi
callq 0x4770
jmp 0x2f1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x2c(%rsp), %rdi
callq 0x4770
jmp 0x3015
movq 0x80bf(%rip), %rdi      # 0xafd0
leaq 0x51fc(%rip), %rsi      # 0x8114
callq 0x21d0
movq 0x80ac(%rip), %rdi      # 0xafd0
leaq 0x51f1(%rip), %rsi      # 0x811c
callq 0x21d0
movq %rax, (%rsp)
movq 0x50(%rsp), %rax
movq 0x30(%rsp), %rcx
leaq (%rcx,%rcx,4), %rcx
movl 0x14(%rax,%rcx,8), %esi
leaq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4720
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x25e0
jmp 0x2f65
leaq 0x18(%rsp), %rdi
callq 0x4740
movq 0x50(%rsp), %rax
imulq $0x28, 0x30(%rsp), %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
je 0x2fe8
movq 0x50(%rsp), %rax
imulq $0x28, 0x30(%rsp), %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpq 0x38(%rsp), %rax
jae 0x2fe8
movq 0x8030(%rip), %rdi      # 0xafd0
leaq 0x5175(%rip), %rsi      # 0x811c
callq 0x21d0
movq %rax, %rdi
movq 0x40(%rsp), %rsi
movq 0x50(%rsp), %rax
imulq $0x28, 0x30(%rsp), %rcx
addq %rcx, %rax
movl (%rax), %eax
addq %rax, %rsi
callq 0x21d0
jmp 0x2fe8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x4740
jmp 0x3015
movq 0x7fe1(%rip), %rdi      # 0xafd0
movq 0x7fca(%rip), %rsi      # 0xafc0
callq 0x2200
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x2e84
jmp 0x3010
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x23a0
nop
// File: coduin[P]epiphany-bin-info/epiphany-bin-info.cpp
// Function: getCmdOption(char**, char**, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
char* getCmdOption(char** begin, char** end, const std::string& option) {
    char** itr = std::find(begin, end, option);
    if (itr != end && ++itr != end) {
        return *itr;
    }
    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x4980
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x3ad7
movq (%rsp), %rax
addq $0x8, %rax
movq %rax, (%rsp)
cmpq 0x10(%rsp), %rax
je 0x3ad7
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x3ae0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: coduin[P]epiphany-bin-info/epiphany-bin-info.cpp
// Function: showHelp(char*)
void showHelp(char* cmd) {
    cout << "Usage: " << cmd
         << " [-h] [-p] [-sec] [-s] [-a] [--nodemangle] file\n";
    cout << "Options:\n";
    cout << "    -h             Show this help.\n";
    cout << "    -p             Show program headers (runtime information).\n";
    cout << "    -sec           Show section headers (linking information).\n";
    cout << "                   Sections stored in external memory are "
            "highlighted.\n";
    cout << "    -s             Show symbols (function names).\n";
    cout << "                   Symbols are sorted by address.\n";
    cout << "    -a             Show all.\n";
    cout << "    --nodemangle   Do not demangle C++ symbol names.\n";
    cout << "  By default, only the total program size in local and external "
            "memory is shown."
         << endl;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq 0x7494(%rip), %rdi      # 0xafd0
leaq 0x46d6(%rip), %rsi      # 0x8219
callq 0x21d0
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x21d0
movq %rax, %rdi
leaq 0x46c3(%rip), %rsi      # 0x8221
callq 0x21d0
movq 0x7466(%rip), %rdi      # 0xafd0
leaq 0x46e1(%rip), %rsi      # 0x8252
callq 0x21d0
movq 0x7453(%rip), %rdi      # 0xafd0
leaq 0x46d8(%rip), %rsi      # 0x825c
callq 0x21d0
movq 0x7440(%rip), %rdi      # 0xafd0
leaq 0x46e9(%rip), %rsi      # 0x8280
callq 0x21d0
movq 0x742d(%rip), %rdi      # 0xafd0
leaq 0x4716(%rip), %rsi      # 0x82c0
callq 0x21d0
movq 0x741a(%rip), %rdi      # 0xafd0
leaq 0x4743(%rip), %rsi      # 0x8300
callq 0x21d0
movq 0x7407(%rip), %rdi      # 0xafd0
leaq 0x4778(%rip), %rsi      # 0x8348
callq 0x21d0
movq 0x73f4(%rip), %rdi      # 0xafd0
leaq 0x4798(%rip), %rsi      # 0x837b
callq 0x21d0
movq 0x73e1(%rip), %rdi      # 0xafd0
leaq 0x47b8(%rip), %rsi      # 0x83ae
callq 0x21d0
movq 0x73ce(%rip), %rdi      # 0xafd0
leaq 0x47c3(%rip), %rsi      # 0x83cc
callq 0x21d0
movq 0x73bb(%rip), %rdi      # 0xafd0
leaq 0x47e6(%rip), %rsi      # 0x8402
callq 0x21d0
movq %rax, %rdi
movq 0x7395(%rip), %rsi      # 0xafc0
callq 0x2200
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: coduin[P]epiphany-bin-info/epiphany-bin-info.cpp
// Function: Symbol::operator<(Symbol const&) const
bool operator<(const Symbol& rhs) const {
        // if this is an absolute value
        // instead of an address, show it AFTER
        // the addresses.
        if ((section != SHN_ABS) && (rhs.section == SHN_ABS)) {
            return true;
        } else if ((section == SHN_ABS) && (rhs.section != SHN_ABS)) {
            return false;
        }
        return value < rhs.value;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0xfff1, 0x14(%rax)     # imm = 0xFFF1
je 0x6632
movq -0x18(%rsp), %rax
cmpl $0xfff1, 0x14(%rax)     # imm = 0xFFF1
jne 0x6632
movb $0x1, -0x1(%rsp)
jmp 0x6670
movq -0x20(%rsp), %rax
cmpl $0xfff1, 0x14(%rax)     # imm = 0xFFF1
jne 0x6655
movq -0x18(%rsp), %rax
cmpl $0xfff1, 0x14(%rax)     # imm = 0xFFF1
je 0x6655
movb $0x0, -0x1(%rsp)
jmp 0x6670
jmp 0x6657
movq -0x20(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: permui[P]CastleAdventure/src/command.hpp
// Function: std::pair<int, double> GetAin<int>()
std::pair<T, double> GetAin() {
	auto t1 = std::chrono::high_resolution_clock::now();
	T ret = GetA<T>();
	auto t2 = std::chrono::high_resolution_clock::now();
	std::chrono::duration<double> sec = t2 - t1;
	return {ret, sec.count()};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
callq 0x3040
movq %rax, -0x18(%rbp)
callq 0x73b0
movl %eax, -0x1c(%rbp)
callq 0x3040
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x7460
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x74b0
movq -0x48(%rbp), %rdi
callq 0x74f0
movsd %xmm0, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x7510
movl -0x10(%rbp), %eax
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: permui[P]CastleAdventure/src/command.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> GetA<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>()
T GetA() {
	T ret;
	while (true) {
		if (std::cin >> ret) {
			std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
			break;
		}
		std::cout << "invalid input!" << std::endl;
		std::cin.clear();
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x32e0
jmp 0x115b2
movq -0x30(%rbp), %rsi
movq 0x8a23(%rip), %rdi      # 0x19fe0
callq 0x32d0
movq %rax, -0x38(%rbp)
jmp 0x115c8
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x32c0
movb %al, -0x39(%rbp)
jmp 0x115e0
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x115e9
jmp 0x11620
callq 0x7540
movq %rax, %rsi
movq 0x89e8(%rip), %rdi      # 0x19fe0
movl $0xa, %edx
callq 0x3140
jmp 0x11604
jmp 0x11685
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3130
jmp 0x116a2
movq 0x89a9(%rip), %rdi      # 0x19fd0
leaq 0xbbe(%rip), %rsi       # 0x121ec
callq 0x3210
movq %rax, -0x48(%rbp)
jmp 0x11639
movq -0x48(%rbp), %rdi
movq 0x897c(%rip), %rsi      # 0x19fc0
callq 0x3250
jmp 0x1164b
movq 0x898e(%rip), %rdi      # 0x19fe0
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x3370
jmp 0x11665
callq 0x7540
movq %rax, %rsi
movq 0x896c(%rip), %rdi      # 0x19fe0
movl $0xa, %edx
callq 0x3140
jmp 0x11680
jmp 0x115b0
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x11698
movq -0x30(%rbp), %rdi
callq 0x3130
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33a0
nopl (%rax,%rax)
// File: permui[P]CastleAdventure/src/base.cpp
// Function: Player::show_state(Grid const&) const
void Player::show_state(const Grid &grid) const {
	std::cout << "You are at (floor " << pos.floor << ", section " << pos.section << ") [" << grid.name << "]" << std::endl;
	std::cout << "shield: " << shield << " | sword: " << sword << " | ";
	std::cout << "BitCoin: " << btc;
	if (with_princess) std::cout << " | with princess";
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x12731(%rip), %rdi     # 0x19fd0
leaq 0xa955(%rip), %rsi      # 0x121fb
callq 0x3210
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x3380
movq %rax, %rdi
leaq 0xa94b(%rip), %rsi      # 0x1220e
callq 0x3210
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x3380
movq %rax, %rdi
leaq 0xa938(%rip), %rsi      # 0x12219
callq 0x3210
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x31f0
movq %rax, %rdi
leaq 0xa91d(%rip), %rsi      # 0x1221d
callq 0x3210
movq %rax, %rdi
movq 0x126b1(%rip), %rsi     # 0x19fc0
callq 0x3250
movq 0x126b5(%rip), %rdi     # 0x19fd0
leaq 0xa8fd(%rip), %rsi      # 0x1221f
callq 0x3210
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x3380
movq %rax, %rdi
leaq 0xa8e8(%rip), %rsi      # 0x12228
callq 0x3210
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x3380
movq %rax, %rdi
leaq 0xa8d5(%rip), %rsi      # 0x12233
callq 0x3210
movq 0x12666(%rip), %rdi     # 0x19fd0
leaq 0xa8c6(%rip), %rsi      # 0x12237
callq 0x3210
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x3380
movq -0x18(%rbp), %rax
testb $0x1, 0x14(%rax)
je 0x79a2
movq 0x1263a(%rip), %rdi     # 0x19fd0
leaq 0xa8a4(%rip), %rsi      # 0x12241
callq 0x3210
movq 0x12627(%rip), %rdi     # 0x19fd0
movq 0x12610(%rip), %rsi     # 0x19fc0
callq 0x3250
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: permui[P]CastleAdventure/src/genmap.cpp
// Function: GenMap()
map<Position, Grid> GenMap() {
	vector<Grid> vec = GenGrids();
	map<Position, Grid> mp;
	for (const Grid &g: vec) mp.emplace(g.pos, g);
	return mp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x84a0
movq -0x70(%rbp), %rdi
movb $0x0, -0x21(%rbp)
callq 0xe9b0
leaq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe840
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe870
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xe8a0
testb $0x1, %al
jne 0xc805
jmp 0xc86a
leaq -0x38(%rbp), %rdi
callq 0xe8e0
movq -0x70(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdx
movq %rdx, %rsi
callq 0xe9d0
movb %dl, -0x81(%rbp)
movq %rax, -0x80(%rbp)
jmp 0xc82e
movb -0x81(%rbp), %al
movq -0x80(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movb %al, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xe930
jmp 0xc7f2
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x3f70
leaq -0x20(%rbp), %rdi
callq 0xe950
jmp 0xc893
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0xc87d
movq -0x70(%rbp), %rdi
callq 0x3f70
leaq -0x20(%rbp), %rdi
callq 0xe950
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33a0
nopl (%rax)
// File: permui[P]CastleAdventure/src/command.cpp
// Function: EncounterPrincess(Player&, Grid&)
void EncounterPrincess(Player &player, Grid &grid) {
	cout << "Lovely Princess Here!" << endl;
	cout << "Commands: pick_her leave_her_alone" << endl;
	while (true) {
		string com = GetA<string>();
		if (com == "pick_her") {
			grid.info.t = GT::None;
			player.with_princess = true;
			break;
		} else if (com == "leave_her_alone") {
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x8c39(%rip), %rdi      # 0x19fd0
leaq 0x1865(%rip), %rsi      # 0x12c03
callq 0x3210
movq %rax, %rdi
movq 0x8c13(%rip), %rsi      # 0x19fc0
callq 0x3250
movq 0x8c17(%rip), %rdi      # 0x19fd0
leaq 0x1859(%rip), %rsi      # 0x12c19
callq 0x3210
movq %rax, %rdi
movq 0x8bf1(%rip), %rsi      # 0x19fc0
callq 0x3250
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x11590
movq -0x50(%rbp), %rdi
leaq 0x1850(%rip), %rsi      # 0x12c3c
callq 0x11750
movb %al, -0x41(%rbp)
jmp 0x113f6
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x113ff
jmp 0x11432
movq -0x10(%rbp), %rax
movl $0x3, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x14(%rax)
movl $0x3, -0x40(%rbp)
jmp 0x11462
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3130
jmp 0x11481
leaq 0x17f3(%rip), %rsi      # 0x12c2c
leaq -0x30(%rbp), %rdi
callq 0x11750
movb %al, -0x51(%rbp)
jmp 0x11447
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x11450
jmp 0x11459
movl $0x3, -0x40(%rbp)
jmp 0x11462
jmp 0x1145b
movl $0x0, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3130
movl -0x40(%rbp), %eax
testl %eax, %eax
je 0x11476
jmp 0x11474
jmp 0x1147b
jmp 0x113d4
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x33a0
nopw (%rax,%rax)
// File: sebastienmeyer2[P]mst-clustering/src/edge.cpp
// Function: Edge::Edge(Node*, Node*)
Edge::Edge(Node* p1, Node* p2){
    /*!
     * @brief Constructeur de l'arrête
     * 
     * @param p1 Le premier noeud constituant l'arrête
     * @param p2 Le second noeud constituant l'arrête
     * 
     * @note Quand aucun poids n'est spécifié et que les noeuds ne portent pas d'information, 
     * on considère qu'il vaut 1. 
     * 
     * @note Voir \ref Edge::Edge(Node* p1, Node* p2, edge_weight_t weight) pour d'autres remarques.
     * 
     */

    this->p1 = p1;
    this->p2 = p2;
    this->weight = p1->dist(p2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x23140
movq -0x20(%rbp), %rax
movsd %xmm0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sebastienmeyer2[P]mst-clustering/src/edge.cpp
// Function: Edge::Edge(Node*, Node*, double)
Edge::Edge(Node* p1, Node* p2, edge_weight_t weight){
    /*!
     * @brief Constructeur de l'arrête avec poids donné
     * 
     * @param p1 Le premier noeud constituant l'arrête
     * @param p2 Le second noeud constituant l'arrête
     * @param weight Le poids de l'arrête
     * 
     * @note Comme on ne considère que des graphes non dirigés, l'ordre de p1 et p2 n'a pas d'importance
     * 
     */

    this->p1 = p1;
    this->p2 = p2;
    this->weight = weight;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sebastienmeyer2[P]mst-clustering/src/edge.cpp
// Function: Edge::other_node(Node*)
Node* Edge::other_node(Node* p){
    /*!
     * @brief Renvoie le noeud de l'arrête différent de \p p
     * 
     * @param p Le noeud de l'arrête qu'on connaît
     * 
     * @return L'autre noeud, ou nullptr si \p p n'appartient pas à l'arrête
     *  
     */

    if(this->p1 != p && this->p2 != p)
        return nullptr;
    
    return this->p1 == p ? this->p2 : this->p1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
je 0xb4b5
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
je 0xb4b5
movq $0x0, -0x8(%rbp)
jmp 0xb4e3
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xb4d0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xb4db
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: sebastienmeyer2[P]mst-clustering/src/point.cpp
// Function: Point::print()
void Point::print()
{
    /*!
     * @brief Enables to print d-dimensional points on the console
     * 
     */

    for (int i = 0; i < d; i ++) {
        std::cout << coords[i] << std::endl;
    }
    std::cout << "\n" << std::endl;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x45204(%rip), %eax     # 0x507f8
jge 0xb62c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x449a3(%rip), %rdi     # 0x4ffb0
callq 0xaee0
movq %rax, %rdi
movq 0x4496c(%rip), %rsi     # 0x4ff88
callq 0xa7e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb5eb
movq 0x4497d(%rip), %rdi     # 0x4ffb0
leaq 0x2bd1d(%rip), %rsi     # 0x37357
callq 0xa780
movq %rax, %rdi
movq 0x4493f(%rip), %rsi     # 0x4ff88
callq 0xa7e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sebastienmeyer2[P]mst-clustering/src/point.cpp
// Function: Point::distance(Point*)
double Point::distance(Point* other)
{
    /*!
     * @brief Evaluates the distance between two instances of the class Point
     * 
     * @param other Another Point to evaluate the distance with 
     * 
     * @return The distance between this point and the \p other 
     */

    double dist = 0.0;
    for (int i = 0; i < d; i ++) {
        dist += std::pow(coords[i] - other->coords[i], 2);
    }
    dist = std::sqrt(dist);

    return dist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x45168(%rip), %eax     # 0x507f8
jge 0xb6d1
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movl $0x2, %edi
callq 0xb940
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb687
movsd -0x18(%rbp), %xmm0
callq 0xa5d0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sebastienmeyer2[P]mst-clustering/src/graph.cpp
// Function: Graph::add_edge(Edge*)
void Graph::add_edge(Edge* e){
    /*!
     * @brief Ajoute l'arrête \p e au graphe
     * 
     * @param e L'arrête
     * 
     * @note Il n'est pas nécessaire d'ajouter les points de \p e au graphe; si ces derniers
     * n'est font pas déjà partie, ils seront ajoutés automatiquement.
     * 
     */

    this->add_node(e->p1);
    this->add_node(e->p2);

    std::unordered_set<Edge*>& adj_p1 = this->adjacency_lists.at(e->p1);
    adj_p1.insert(e);

    std::unordered_set<Edge*>& adj_p2 = this->adjacency_lists.at(e->p2);
    adj_p2.insert(e);

    this->all_edges.insert(e);

    e->id = this->edge_counter;
    this->edge_id_mapper.insert(std::pair<edge_id_t, Edge*>(this->edge_counter++, e));

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xd2f0
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xd2f0
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe0f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xe120
movq -0x88(%rbp), %rdi
movq %rax, -0x28(%rbp)
movb %dl, -0x20(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0xe0f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xe120
movq -0x88(%rbp), %rdi
movq %rax, -0x40(%rbp)
movb %dl, -0x38(%rbp)
addq $0x38, %rdi
leaq -0x10(%rbp), %rsi
callq 0xe120
movq -0x88(%rbp), %rcx
movq %rax, -0x50(%rbp)
movb %dl, -0x48(%rbp)
movl 0xe4(%rcx), %edx
movq -0x10(%rbp), %rax
movl %edx, 0x18(%rax)
movq %rcx, %rax
addq $0xa8, %rax
movq %rax, -0x80(%rbp)
movl 0xe4(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0xe4(%rcx)
movl %eax, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x64(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xe1a0
movq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xe160
movq %rax, -0x78(%rbp)
movb %dl, -0x70(%rbp)
addq $0x90, %rsp
popq %rbp
retq
// File: sebastienmeyer2[P]mst-clustering/src/graph.cpp
// Function: Graph::Graph(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Graph::Graph(std::string file_path) : Graph()
{
    /*!
     * @brief Builds a graph from scratch, with its nodes and edges contained in a file
     * 
     * @param file_path The path to the file 
     * 
     */
    build_from_ashiip(this, file_path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xc480
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xa2a0
jmp 0xd030
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc4f0
jmp 0xd03f
leaq -0x30(%rbp), %rdi
callq 0xa470
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd071
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa470
movq -0x50(%rbp), %rdi
callq 0xddf0
movq -0x38(%rbp), %rdi
callq 0xade0
nopw %cs:(%rax,%rax)
// File: sebastienmeyer2[P]mst-clustering/src/graph.cpp
// Function: Graph::add_node(Node*)
void Graph::add_node(Node* n){
    /*!
     * @brief Ajoute le noeud \p n au graphe
     * 
     * @param n Le noeud
     * 
     */


    if(this->has_node(n))
        return;

    this->adjacency_lists.insert(
        std::pair<Node*, std::unordered_set<Edge*> >(
                                                        n,
                                                        std::unordered_set<Edge*>()
                                                    )
                                );
    
    n->set_id(this->node_counter);
    this->node_id_mapper.insert(std::pair<node_id_t, Node*>(this->node_counter++, n));

    
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
movq -0x10(%rbp), %rsi
callq 0xd490
testb $0x1, %al
jne 0xd31d
jmp 0xd322
jmp 0xd43a
movq -0xe0(%rbp), %rax
movq %rax, -0xf0(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
movq $0x0, -0x60(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xd8d0
movq -0xe8(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xe060
jmp 0xd373
movq -0xf0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xe020
movb %dl, -0xf9(%rbp)
movq %rax, -0xf8(%rbp)
jmp 0xd392
movb -0xf9(%rbp), %al
movq -0xf8(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
movb %al, -0xa8(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xe0a0
leaq -0x90(%rbp), %rdi
callq 0xdf50
movq -0xe0(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0xe0(%rax), %esi
callq 0x24660
movq -0xe0(%rbp), %rcx
movq %rcx, %rax
addq $0x70, %rax
movq %rax, -0x108(%rbp)
movl 0xe0(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0xe0(%rcx)
movl %eax, -0xc4(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0xc4(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xe0c0
movq -0x108(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0xda30
movq %rax, -0xd8(%rbp)
movb %dl, -0xd0(%rbp)
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0xd472
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xe0a0
leaq -0x90(%rbp), %rdi
callq 0xdf50
movq -0x98(%rbp), %rdi
callq 0xade0
nopw (%rax,%rax)
// File: sebastienmeyer2[P]mst-clustering/src/graph.cpp
// Function: Graph::get_nodes()
std::vector<Node*> Graph::get_nodes()
{
    /*!
     * @brief Renvoie tous les noeuds du graphe (pointeurs)
     * 
     * @return Un vecteur avec les noeuds du graphe
     * 
     */

    std::vector<Node*> nodes;
    for (auto kv : this->adjacency_lists) {
        nodes.push_back(kv.first);
    }

    return nodes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xde40
movq -0x88(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe1f0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdff0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdf90
testb $0x1, %al
jne 0xd5a0
jmp 0xd602
leaq -0x28(%rbp), %rdi
callq 0xe220
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0xe250
jmp 0xd5b7
movq -0x98(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xe290
jmp 0xd5c9
leaq -0x70(%rbp), %rdi
callq 0xe300
leaq -0x28(%rbp), %rdi
callq 0xe320
jmp 0xd58d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xd628
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xe300
jmp 0xd628
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xd618
movq -0x98(%rbp), %rdi
callq 0xded0
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0xded0
movq -0x78(%rbp), %rdi
callq 0xade0
nopl (%rax)
// File: sebastienmeyer2[P]mst-clustering/src/graph.cpp
// Function: Graph::get_any_node()
Node* Graph::get_any_node()
{
    /*!
     * @brief Renvoie un sommet au hasard dans les sommets du graphe
     * 
     * @return Un noeud au hasard
     * 
     */

    std::vector<Node*> nodes = this->get_nodes();
    int n = this->get_number_of_nodes();

    std::random_device rd; 
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> distrib(0, n-1);

    int idx = distrib(gen);

    return nodes[idx];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2770, %rsp           # imm = 0x2770
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x2760(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xd530
movq -0x2760(%rbp), %rdi
callq 0xd510
movl %eax, -0x24(%rbp)
leaq -0x13b0(%rbp), %rdi
callq 0xe3a0
jmp 0xd6d0
leaq -0x13b0(%rbp), %rdi
callq 0xe440
movl %eax, -0x2764(%rbp)
jmp 0xd6e4
movl -0x2764(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x2748(%rbp), %rdi
callq 0xe460
jmp 0xd6fc
movl -0x24(%rbp), %edx
decl %edx
leaq -0x2750(%rbp), %rdi
xorl %esi, %esi
callq 0xe490
jmp 0xd711
leaq -0x2750(%rbp), %rdi
leaq -0x2748(%rbp), %rsi
callq 0xe4c0
movl %eax, -0x2768(%rbp)
jmp 0xd72c
movl -0x2768(%rbp), %eax
movl %eax, -0x2754(%rbp)
movslq -0x2754(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xdeb0
movq (%rax), %rax
movq %rax, -0x2770(%rbp)
leaq -0x13b0(%rbp), %rdi
callq 0xe4f0
leaq -0x20(%rbp), %rdi
callq 0xded0
movq -0x2770(%rbp), %rax
addq $0x2770, %rsp           # imm = 0x2770
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x13b8(%rbp)
movl %eax, -0x13bc(%rbp)
jmp 0xd7a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x13b8(%rbp)
movl %eax, -0x13bc(%rbp)
leaq -0x13b0(%rbp), %rdi
callq 0xe4f0
leaq -0x20(%rbp), %rdi
callq 0xded0
movq -0x13b8(%rbp), %rdi
callq 0xade0
nop
// File: sebastienmeyer2[P]mst-clustering/src/graph.cpp
// Function: Graph::total_weight()
double Graph::total_weight()
{
    /*!
     * @brief Returns the total weight of the edges of this graph
     * 
     * @return Weight of all edges (by unique identifier)
     * 
     */

    double weight = 0.0;
    for (Edge* e : this->all_edges) {
        weight += e->weight;
    }
    return weight;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
addq $0x38, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe520
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe550
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe580
testb $0x1, %al
jne 0xd80d
jmp 0xd83b
leaq -0x20(%rbp), %rdi
callq 0xe5b0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xe5e0
jmp 0xd7fa
movsd -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sebastienmeyer2[P]mst-clustering/src/node.cpp
// Function: Node::dist(Node*)
double Node::dist(Node* other)
{    
    /*!
     * @brief Returns the Euclidian distance between two Nodes
     * 
     * @param other The \p other Node to evaluate distance with
     * 
     * @return The Euclidian distance between this Node and the \p other Node
     * 
     */

    Point* p1_p = this->p;
    Point* p2_p = other->get_point();

    if (p1_p != NULL && p2_p != NULL) {
        if (p1_p->get_dim() == p2_p->get_dim()) {
            return p1_p->distance(p2_p);
        }
    }

    return 1; // arbitrary choice
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x23100
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x231ab
cmpq $0x0, -0x28(%rbp)
je 0x231ab
movq -0x20(%rbp), %rdi
callq 0xb5c0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb5c0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jne 0x231a9
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xb660
movsd %xmm0, -0x8(%rbp)
jmp 0x231b8
jmp 0x231ab
movsd 0x13ef5(%rip), %xmm0    # 0x370a8
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sebastienmeyer2[P]mst-clustering/src/mst_algorithm.cpp
// Function: MSTAlgorithm::MSTAlgorithm(Graph*)
MSTAlgorithm::MSTAlgorithm(Graph* graph)
{
    /*!
     * @brief Constructor of a MST Algorithm
     * 
     * @param graph A pointer towards the graph of which we want to compute the MST
     * 
     */

    this->initial_graph = graph;
    this->mst_weight = 0.0;
    this->treated = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
leaq 0x29781(%rip), %rax     # 0x4fc60
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rdi
callq 0xc480
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0xf8(%rax)
movb $0x0, 0x100(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sebastienmeyer2[P]mst-clustering/src/union_find.cpp
// Function: UnionFind::UnionFind(std::vector<Node*, std::allocator<Node*>>)
UnionFind::UnionFind(std::vector<Node*> nodes) 
{
    /*!
     * @brief Builds the Union-Find data structure from a vector
     * of nodes
     * 
     * @param nodes Nodes of the graph
     * 
     */

    this->num_classes = nodes.size();
    for(Node* n : nodes) {
        this->parent.insert(std::pair<Node*, Node*>(n, n));
        this->rank.insert(std::pair<Node*, int>(n, 1));
        this->representatives.insert(n);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x27a30
movq -0xa0(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1bb20
movq -0xa0(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0xb0(%rbp)
callq 0xdbe0
movq -0xa8(%rbp), %rdi
callq 0x15cd0
movq -0xa8(%rbp), %rsi
movq %rax, %rcx
movq -0xa0(%rbp), %rax
movl %ecx, 0xa8(%rax)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15bd0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15a20
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x27a50
testb $0x1, %al
jne 0x3107f
jmp 0x311c4
leaq -0x20(%rbp), %rdi
callq 0x15fb0
movq %rax, %rcx
movq -0xa0(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x30(%rbp)
movq %rax, -0xc0(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rdx
movq %rdx, %rsi
callq 0x27ad0
jmp 0x310b2
movq -0xc0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x27a90
movb %dl, -0xc9(%rbp)
movq %rax, -0xc8(%rbp)
jmp 0x310d1
movq -0xa0(%rbp), %rax
movb -0xc9(%rbp), %cl
movq -0xc8(%rbp), %rdx
movq %rdx, -0x60(%rbp)
movb %cl, -0x58(%rbp)
addq $0x38, %rax
movq %rax, -0xd8(%rbp)
movl $0x1, -0x74(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x74(%rbp), %rdx
callq 0x1bd00
jmp 0x31111
movq -0xd8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1bcc0
movb %dl, -0xe1(%rbp)
movq %rax, -0xe0(%rbp)
jmp 0x31130
movq -0xa0(%rbp), %rdi
movb -0xe1(%rbp), %al
movq -0xe0(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movb %al, -0x80(%rbp)
addq $0x70, %rdi
leaq -0x30(%rbp), %rsi
callq 0xdd40
movb %dl, -0xf1(%rbp)
movq %rax, -0xf0(%rbp)
jmp 0x3116a
movb -0xf1(%rbp), %al
movq -0xf0(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movb %al, -0x90(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x27b00
jmp 0x31069
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xdc60
movq -0xb8(%rbp), %rdi
callq 0x1be10
movq -0xa0(%rbp), %rdi
callq 0x1be30
jmp 0x311cd
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xade0
nopw %cs:(%rax,%rax)
// File: sebastienmeyer2[P]mst-clustering/src/union_find.cpp
// Function: UnionFind::Find(Node*)
Node* UnionFind::Find(Node* node)
{
    /*!
     * @brief For a \p node that belongs to the data structure, find its 
     * representative in the data structure using path compression
     * 
     * @param node Node of which we want the reprensentative
     * 
     * @return The representative of the initial node
     * 
     */

    assert(("This node is not part of the data structure", this->get_parent(node) != NULL));

    Node* parent = this->get_parent(node);

    if(node == parent) {
        return parent;
    }

    Node* r = this->Find(parent);
    this->parent[node] = r;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x31220
cmpq $0x0, %rax
je 0x31389
jmp 0x313a8
leaq 0x6673(%rip), %rdi      # 0x37a03
leaq 0x66bc(%rip), %rsi      # 0x37a53
movl $0x65, %edx
leaq 0x66c3(%rip), %rcx      # 0x37a66
callq 0xa4a0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x31220
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x313cd
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x31402
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x31360
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x315e0
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sebastienmeyer2[P]mst-clustering/src/union_find.cpp
// Function: UnionFind::Union(Node*, Node*)
void UnionFind::Union(Node* n1, Node* n2)
{
    /*!
     * @brief For two nodes \p n1 and \p n2 of the data structure, computes 
     * the union of their two classes 
     * 
     * @param n1 First node 
     * @param n2 Second node
     * 
     */

    Node* rep1 = this->Find(n1);
    Node* rep2 = this->Find(n2);

    if(rep1 != rep2) {
        this->num_classes -= 1; // proceeding with Union

        int r1 = this->get_rank(rep1);
        int r2 = this->get_rank(rep2);

        if(r1 > r2) {
            this->parent[rep2] = rep1;
            this->representatives.erase(rep2);
        } else if(r2 > r1) {
            this->parent[rep1] = rep2;
            this->representatives.erase(rep1);
        } else { // arbitrary choice
            this->parent[rep1] = rep2;
            this->representatives.erase(rep1);
            this->rank[rep2] += 1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x31360
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
callq 0x31360
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x3153e
movq -0x38(%rbp), %rdi
movl 0xa8(%rdi), %eax
subl $0x1, %eax
movl %eax, 0xa8(%rdi)
movq -0x20(%rbp), %rsi
callq 0x31290
movq -0x38(%rbp), %rdi
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rsi
callq 0x31290
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jle 0x314be
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x315e0
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdi
movq %rcx, (%rax)
addq $0x70, %rdi
leaq -0x28(%rbp), %rsi
callq 0x31610
jmp 0x3153c
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jle 0x314f5
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x315e0
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rdi
movq %rcx, (%rax)
addq $0x70, %rdi
leaq -0x20(%rbp), %rsi
callq 0x31610
jmp 0x3153a
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x315e0
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rdi
movq %rcx, (%rax)
addq $0x70, %rdi
leaq -0x20(%rbp), %rsi
callq 0x31610
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
leaq -0x28(%rbp), %rsi
callq 0x31640
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x3153c
jmp 0x3153e
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: sebastienmeyer2[P]mst-clustering/src/kmeans.cpp
// Function: Cloud::~Cloud()
Cloud::~Cloud()
{
    /*!
     * @brief Destructor of the cloud class
     */

	delete[] centers;
	delete[] points;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x32833
movq -0x10(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rcx), %rdx
movq %rdx, -0x28(%rbp)
shlq $0x4, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x20(%rbp)
je 0x3281e
movq -0x20(%rbp), %rdi
addq $-0x10, %rdi
movq %rdi, -0x38(%rbp)
callq 0xb590
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x20(%rbp)
jne 0x327fc
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
shlq $0x4, %rsi
addq $0x8, %rsi
callq 0xaf60
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x328a6
movq -0x40(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rcx), %rdx
movq %rdx, -0x50(%rbp)
shlq $0x4, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x48(%rbp)
je 0x32891
movq -0x48(%rbp), %rdi
addq $-0x10, %rdi
movq %rdi, -0x60(%rbp)
callq 0xb590
movq -0x40(%rbp), %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x48(%rbp)
jne 0x3286f
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
shlq $0x4, %rsi
addq $0x8, %rsi
callq 0xaf60
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: sebastienmeyer2[P]mst-clustering/src/kmeans.cpp
// Function: Cloud::add_point(Point&, int)
void Cloud::add_point(Point &p, int label)
{
    /*!
     * @brief Adds a point in the cloud by copying its values
     * 
     * @param p The point to be added
	 * @param label A label to give to this point
     */

	assert(("Too much points!", n < nmax));
	assert(("No center to assign to this point!", label<k));

	for(int m = 0; m < d; m++)
	{
		points[n].coords[m] = p.coords[m];
	}

	points[n].label = label;

	n++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x4(%rcx), %eax
cmpl 0xc(%rcx), %eax
jge 0x328d5
jmp 0x328f4
leaq 0x51cd(%rip), %rdi      # 0x37aa9
leaq 0x51e5(%rip), %rsi      # 0x37ac8
movl $0x2b, %edx
leaq 0x51e8(%rip), %rcx      # 0x37ad7
callq 0xa4a0
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x32902
jmp 0x32921
leaq 0x5215(%rip), %rdi      # 0x37b1e
leaq 0x51b8(%rip), %rsi      # 0x37ac8
movl $0x2c, %edx
leaq 0x51bb(%rip), %rcx      # 0x37ad7
callq 0xa4a0
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3296d
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rdx
movsd (%rax,%rdx,8), %xmm0
movq 0x10(%rcx), %rax
movslq 0x4(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x32928
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edx
movq 0x10(%rax), %rcx
movslq 0x4(%rax), %rsi
shlq $0x4, %rsi
addq %rsi, %rcx
movl %edx, 0x8(%rcx)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sebastienmeyer2[P]mst-clustering/src/kmeans.cpp
// Function: Cloud::set_center(Point&, int)
void Cloud::set_center(Point &p, int j)
{
    /*!
     * @brief Enables to change centers from this cloud
     * 
     * @param p A point to change the center by
	 * @param j Index of the center to be modified
     */

	for(int m = 0; m < d; m++)
		centers[j].coords[m] = p.coords[m];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl (%rcx), %eax
jge 0x32a93
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x18(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x32a4e
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sebastienmeyer2[P]mst-clustering/src/kmeans.cpp
// Function: Cloud::intracluster_variance()
double Cloud::intracluster_variance()
{
    /*!
     * @brief Computes the intracluster variance in this cloud
     * 
     * @return The intracluster variance
     */

	double intraclusterVar = 0.0;
	for(int i = 0; i < this->n; i ++){
		intraclusterVar += points[i].distance(&(centers[points[i].label]));
	}
	if (n > 0) {
		intraclusterVar /= n;
	}

	return intraclusterVar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x32b1a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rdi
movq 0x18(%rax), %rsi
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq 0x8(%rax), %rax
shlq $0x4, %rax
addq %rax, %rsi
callq 0xb660
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x32ac3
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jle 0x32b3b
movq -0x20(%rbp), %rax
cvtsi2sdl 0x4(%rax), %xmm1
movsd -0x10(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sebastienmeyer2[P]mst-clustering/src/kmeans.cpp
// Function: Cloud::set_voronoi_labels()
int Cloud::set_voronoi_labels()
{
    /*!
     * @brief E-step in the kmeans algorithm
     */

	int changedLabels = 0;

	for (int i = 0; i < this->n; i ++){
		int pointLabel = points[i].label;
		int newLabel = points[i].label;
		double minDist = points[i].distance(&(centers[pointLabel]));

		for (int j = 0; j < this->k; j ++){
			double dist = points[i].distance(&(centers[j]));
			if (dist < minDist || (dist == minDist && j < newLabel)) {
				minDist = dist;
				newLabel = j;
			}
		}

		if (newLabel != pointLabel){
			points[i].label = newLabel;
			changedLabels += 1;
		}
	}
	
	return changedLabels;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x38(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x32c94
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl 0x8(%rcx), %ecx
movl %ecx, -0x14(%rbp)
movq 0x10(%rax), %rcx
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movl 0x8(%rcx), %ecx
movl %ecx, -0x18(%rbp)
movq 0x10(%rax), %rdi
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rdi
movq 0x18(%rax), %rsi
movslq -0x14(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
callq 0xb660
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x32c5a
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rdi
movq 0x18(%rax), %rsi
movslq -0x24(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
callq 0xb660
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
ja 0x32c3d
movsd -0x30(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jne 0x32c4d
jp 0x32c4d
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x32c4d
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x32c4f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x32bdf
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x32c84
movq -0x38(%rbp), %rax
movl -0x18(%rbp), %ecx
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x32c86
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x32b72
movl -0xc(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)