LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: QFSW[P]MIPS1-Simulator/src/IInstructions.cpp
// Function: Clarkitechture::MIPS::LWRInstr::execute(Clarkitechture::MIPS::MemoryMap&, Clarkitechture::MIPS::RegisterMap&)
void LWRInstr::execute(MemoryMap &mem, RegisterMap& reg)
{
    uint32_t addr = reg.read(rs) + (int16_t)constant;
    uint32_t byteIndex = addr % 4;
    uint32_t wordIndex = addr - byteIndex;
    uint32_t mask = 0xFFFFFFFF;

    uint32_t rawWord = mem.read<uint32_t>(wordIndex);
    byte* byteArray = reinterpret_cast<byte*>(&rawWord);
    
    for (int i = 0; i <= byteIndex; ++i)
    {
        data <<= 8;
        data |= byteArray[3 - i];
        mask <<= 8;
    }
    data |= (reg.read(rt) & mask);
    reg.write(rt, data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x8(%rax), %eax
movl %eax, %esi
callq 0x10b60
movq -0x48(%rbp), %rcx
movswl 0xa(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x8c00
movl %eax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x20(%rbp), %eax
ja 0x85c3
movq -0x48(%rbp), %rax
movl 0xc(%rax), %ecx
shll $0x8, %ecx
movl %ecx, 0xc(%rax)
movq -0x38(%rbp), %rcx
movl $0x3, %edx
subl -0x3c(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movl -0x28(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x28(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x8581
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rdi
movzbl 0x9(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, %ecx
movq -0x48(%rbp), %rax
andl -0x28(%rbp), %ecx
orl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rdi
movzbl 0x9(%rax), %ecx
movl %ecx, %esi
movl 0xc(%rax), %edx
callq 0x10c00
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: QFSW[P]MIPS1-Simulator/src/MemoryMap.hpp
// Function: unsigned int Clarkitechture::MIPS::MemoryMap::bswap<unsigned int>(unsigned int)
T bswap(T data)
            {
                byte* dataArray = reinterpret_cast<byte*>(&data);
                T newData = 0;
                for (int i = 0; i < sizeof(T); ++i)
                {
                    newData |= dataArray[i] << ((sizeof(T) - i - 1) * 8);
                }

                return newData;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
cmpq $0x4, %rax
jae 0xa79e
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movslq -0x20(%rbp), %rdx
movl $0x4, %ecx
subq %rdx, %rcx
subq $0x1, %rcx
shlq $0x3, %rcx
shll %cl, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xa761
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: QFSW[P]MIPS1-Simulator/src/Instructions.cpp
// Function: Clarkitechture::MIPS::BinaryDecoder::decodeInstruction(unsigned int)
Instruction* BinaryDecoder::decodeInstruction(uint32_t bin)
{
	byte opcode = 0b111111 & (bin >> (32 - 6));
	if (opcode == 0) { return decodeRInstruction(bin); }
    else if (opcode == 0b10 || opcode == 0b11) { return decodeJInstruction(bin); }
	else { return decodeIInstruction(bin); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x1a, %eax
andl $0x3f, %eax
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %eax
cmpl $0x0, %eax
jne 0xbdee
movl -0xc(%rbp), %edi
callq 0xbe30
movq %rax, -0x8(%rbp)
jmp 0xbe1a
movzbl -0xd(%rbp), %eax
cmpl $0x2, %eax
je 0xbe00
movzbl -0xd(%rbp), %eax
cmpl $0x3, %eax
jne 0xbe0e
movl -0xc(%rbp), %edi
callq 0xc950
movq %rax, -0x8(%rbp)
jmp 0xbe1a
movl -0xc(%rbp), %edi
callq 0xca30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: QFSW[P]MIPS1-Simulator/src/Instructions.cpp
// Function: Clarkitechture::MIPS::BinaryDecoder::decodeJInstruction(unsigned int)
JInstruction* BinaryDecoder::decodeJInstruction(uint32_t bin)
{
    byte opcode = 0b111111 & (bin >> (32 - 6));
    uint32_t target = 0x03FFFFFF & bin;
    
    switch (opcode)
    {
    default:
        case 0b000010: return new JInstr(target);
        case 0b000011: return new JALInstr(target);
        throw BadInstructionDecode(bin, "invalid or unsupported function code - " + toBinStr(opcode));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x1a, %eax
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
andl $0x3ffffff, %eax        # imm = 0x3FFFFFF
movl %eax, -0x14(%rbp)
movzbl -0xd(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x2, %eax
je 0xc989
jmp 0xc97d
movl -0x28(%rbp), %eax
subl $0x3, %eax
je 0xc9cd
jmp 0xc987
jmp 0xc989
movl $0x10, %edi
callq 0x62a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0xd7e0
jmp 0xc9a7
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xca11
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x62b0
jmp 0xca1b
movl $0x10, %edi
callq 0x62a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %esi
callq 0xd820
jmp 0xc9eb
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xca11
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x62b0
jmp 0xca1b
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x64b0
nopw %cs:(%rax,%rax)
// File: QFSW[P]MIPS1-Simulator/src/Instructions.cpp
// Function: Clarkitechture::MIPS::RInstruction::RInstruction(unsigned char, unsigned char, unsigned char, unsigned char)
RInstruction::RInstruction(byte rs, byte rt, byte rd, byte shamt)
{
	this->rs = rs;
	this->rt = rt;
	this->rd = rd;
	this->shamt = shamt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movb %sil, -0x9(%rbp)
movb %dl, -0xa(%rbp)
movb %cl, -0xb(%rbp)
movb %al, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xed00
movq -0x18(%rbp), %rax
leaq 0xef3c(%rip), %rcx      # 0x1c580
addq $0x10, %rcx
movq %rcx, (%rax)
movb -0x9(%rbp), %cl
movb %cl, 0x8(%rax)
movb -0xa(%rbp), %cl
movb %cl, 0x9(%rax)
movb -0xb(%rbp), %cl
movb %cl, 0xa(%rax)
movb -0xc(%rbp), %cl
movb %cl, 0xb(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: QFSW[P]MIPS1-Simulator/src/Instructions.cpp
// Function: Clarkitechture::MIPS::BranchIInstruction::execute(Clarkitechture::MIPS::MemoryMap&, Clarkitechture::MIPS::RegisterMap&)
void BranchIInstruction::execute(MemoryMap &mem, RegisterMap &reg)
{
    int32_t offset = ((int16_t)constant) << 2;
    branchAddr = reg.PC + offset;
    conditionMet = evaluateCondition(reg);
    if (requiresLink()) { reg.write(31, reg.PC + 4); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movswl 0xa(%rdi), %eax
shll $0x2, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, 0x10(%rdi)
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x28(%rbp), %rdi
andb $0x1, %al
movb %al, 0xc(%rdi)
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0xd781
jmp 0xd798
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
addl $0x4, %edx
movl $0x1f, %esi
callq 0x10c00
addq $0x30, %rsp
popq %rbp
retq
nop
// File: QFSW[P]MIPS1-Simulator/src/MemoryMap.cpp
// Function: Clarkitechture::MIPS::MemoryMap::MemoryMap(Clarkitechture::MIPS::MemoryMap const&)
MemoryMap::MemoryMap(const MemoryMap &a)
{
    memory = a.memory;
    
    instrMemorySize = a.instrMemorySize;
    if (instrMemorySize > 0)
    {
        instrMemory = new byte[instrMemorySize];
        memcpy(instrMemory, a.instrMemory, a.instrMemorySize);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0xf3a0
movq -0x28(%rbp), %rdi
movq $0x0, 0x40(%rdi)
movq -0x10(%rbp), %rsi
callq 0xf3e0
jmp 0xf2eb
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
movq %rcx, 0x40(%rax)
cmpq $0x0, 0x40(%rax)
jbe 0xf353
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x6030
movq %rax, -0x38(%rbp)
jmp 0xf315
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
callq 0x6230
jmp 0xf353
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xf3c0
jmp 0xf359
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x64b0
nopw %cs:(%rax,%rax)
// File: QFSW[P]MIPS1-Simulator/src/RInstructions.cpp
// Function: Clarkitechture::MIPS::ADDInstr::execute(Clarkitechture::MIPS::MemoryMap&, Clarkitechture::MIPS::RegisterMap&)
void ADDInstr::execute(MemoryMap &mem, RegisterMap& reg)
{
    int32_t left = reg.read(rs);
    int32_t right = reg.read(rt);
    int32_t result = left + right;
    
    bool overflow = sameSign(left, right) && !sameSign(left, result);
    if (overflow) { throw BadArithmeticOperation("ADD encountered an overflow"); }
    
    reg.write(rd, result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x8(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, %ecx
movq -0x68(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x9(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x8b10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x5e(%rbp)
jne 0xfeab
jmp 0xfebb
movl -0x1c(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x8b10
xorb $-0x1, %al
movb %al, -0x5e(%rbp)
movb -0x5e(%rbp), %al
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
je 0xff6d
movb $0x1, -0x5d(%rbp)
movl $0x48, %edi
callq 0x6140
movq %rax, -0x78(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x64c0
movq -0x70(%rbp), %rdx
leaq 0x4c25(%rip), %rsi      # 0x14b1c
leaq -0x48(%rbp), %rdi
callq 0x8b50
jmp 0xff02
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6730
jmp 0xff11
movq -0x78(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
leaq 0xbf70(%rip), %rsi      # 0x1be90
leaq -0x8817(%rip), %rdx     # 0x7710
callq 0x6470
jmp 0xff95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xff51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6190
leaq -0x49(%rbp), %rdi
callq 0x62e0
testb $0x1, -0x5d(%rbp)
jne 0xff62
jmp 0xff6b
movq -0x78(%rbp), %rdi
callq 0x61f0
jmp 0xff8c
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rdi
movzbl 0xa(%rax), %eax
movl %eax, %esi
movl -0x24(%rbp), %edx
callq 0x10c00
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x64b0
nopw %cs:(%rax,%rax)
// File: QFSW[P]MIPS1-Simulator/src/RInstructions.cpp
// Function: Clarkitechture::MIPS::SUBInstr::execute(Clarkitechture::MIPS::MemoryMap&, Clarkitechture::MIPS::RegisterMap&)
void SUBInstr::execute(MemoryMap &mem, RegisterMap& reg)
{
    int32_t left = reg.read(rs);
    int32_t right = reg.read(rt);
    int32_t result = left - right;
    
    bool overflow = !sameSign(left, right) && !sameSign(left, result);
    if (overflow) { throw BadArithmeticOperation("SUB encountered an overflow"); }
    
    reg.write(rd, result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x8(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, %ecx
movq -0x68(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x9(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
callq 0x8b10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x5e(%rbp)
jne 0x10089
movl -0x1c(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x8b10
xorb $-0x1, %al
movb %al, -0x5e(%rbp)
movb -0x5e(%rbp), %al
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
je 0x1013b
movb $0x1, -0x5d(%rbp)
movl $0x48, %edi
callq 0x6140
movq %rax, -0x78(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x64c0
movq -0x70(%rbp), %rdx
leaq 0x4a73(%rip), %rsi      # 0x14b38
leaq -0x48(%rbp), %rdi
callq 0x8b50
jmp 0x100d0
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6730
jmp 0x100df
movq -0x78(%rbp), %rdi
movb $0x0, -0x5d(%rbp)
leaq 0xbda2(%rip), %rsi      # 0x1be90
leaq -0x89e5(%rip), %rdx     # 0x7710
callq 0x6470
jmp 0x10163
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1011f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6190
leaq -0x49(%rbp), %rdi
callq 0x62e0
testb $0x1, -0x5d(%rbp)
jne 0x10130
jmp 0x10139
movq -0x78(%rbp), %rdi
callq 0x61f0
jmp 0x1015a
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rdi
movzbl 0xa(%rax), %eax
movl %eax, %esi
movl -0x24(%rbp), %edx
callq 0x10c00
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x64b0
nopw %cs:(%rax,%rax)
// File: QFSW[P]MIPS1-Simulator/src/RInstructions.cpp
// Function: Clarkitechture::MIPS::NORInstr::execute(Clarkitechture::MIPS::MemoryMap&, Clarkitechture::MIPS::RegisterMap&)
void NORInstr::execute(MemoryMap &mem, RegisterMap& reg)
{
    uint32_t left = reg.read(rs);
    uint32_t right = reg.read(rt);
    uint32_t result = ~(left | right);
    reg.write(rd, result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x8(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x9(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
orl -0x20(%rbp), %ecx
xorl $-0x1, %ecx
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0xa(%rax), %eax
movl %eax, %esi
movl -0x24(%rbp), %edx
callq 0x10c00
addq $0x30, %rsp
popq %rbp
retq
// File: QFSW[P]MIPS1-Simulator/src/RInstructions.cpp
// Function: Clarkitechture::MIPS::MULTInstr::execute(Clarkitechture::MIPS::MemoryMap&, Clarkitechture::MIPS::RegisterMap&)
void MULTInstr::execute(MemoryMap &mem, RegisterMap& reg)
{
    int64_t left = (int32_t)reg.read(rs);
    int64_t right = (int32_t)reg.read(rt);
    int64_t result = left * right;
    reg.lo = 0xFFFFFFFF & result;
    reg.hi = 0xFFFFFFFF & (result >> 32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x8(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x9(%rax), %eax
movl %eax, %esi
callq 0x10b60
cltq
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
imulq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rax
sarq $0x20, %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: QFSW[P]MIPS1-Simulator/src/RInstructions.cpp
// Function: Clarkitechture::MIPS::MULTUInstr::execute(Clarkitechture::MIPS::MemoryMap&, Clarkitechture::MIPS::RegisterMap&)
void MULTUInstr::execute(MemoryMap &mem, RegisterMap& reg)
{
    uint64_t left = reg.read(rs);
    uint64_t right = reg.read(rt);
    uint64_t result = left * right;
    reg.lo = 0xFFFFFFFF & result;
    reg.hi = 0xFFFFFFFF & (result >> 32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x8(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, %ecx
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x9(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
imulq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rax
shrq $0x20, %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: QFSW[P]MIPS1-Simulator/src/RInstructions.cpp
// Function: Clarkitechture::MIPS::DIVInstr::execute(Clarkitechture::MIPS::MemoryMap&, Clarkitechture::MIPS::RegisterMap&)
void DIVInstr::execute(MemoryMap &mem, RegisterMap& reg)
{
    int32_t left = reg.read(rs);
    int32_t right = reg.read(rt);
    
    if (right != 0)
    {
        int32_t quotient = left / right;
        int32_t remainder = left % right;
        reg.lo = quotient;
        reg.hi = remainder;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x8(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x9(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x10554
movl -0x1c(%rbp), %eax
cltd
idivl -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
cltd
idivl -0x20(%rbp)
movl %edx, -0x28(%rbp)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: QFSW[P]MIPS1-Simulator/src/RInstructions.cpp
// Function: Clarkitechture::MIPS::DIVUInstr::execute(Clarkitechture::MIPS::MemoryMap&, Clarkitechture::MIPS::RegisterMap&)
void DIVUInstr::execute(MemoryMap &mem, RegisterMap& reg)
{
    uint32_t left = reg.read(rs);
    uint32_t right = reg.read(rt);
    
    if (right != 0)
    {
        uint32_t quotient = left / right;
        uint32_t remainder = left % right;
        reg.lo = quotient;
        reg.hi = remainder;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x8(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x9(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x105d6
movl -0x1c(%rbp), %eax
xorl %edx, %edx
divl -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
xorl %edx, %edx
divl -0x20(%rbp)
movl %edx, -0x28(%rbp)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: QFSW[P]MIPS1-Simulator/src/RInstructions.cpp
// Function: Clarkitechture::MIPS::SLLVInstr::execute(Clarkitechture::MIPS::MemoryMap&, Clarkitechture::MIPS::RegisterMap&)
void SLLVInstr::execute(MemoryMap &mem, RegisterMap& reg)
{
    uint32_t value = reg.read(rt);
    uint32_t newShamt = 0b11111 & reg.read(rs);
    value <<= newShamt;
    reg.write(rd, value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x9(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0x8(%rax), %eax
movl %eax, %esi
callq 0x10b60
movl %eax, %ecx
movq -0x28(%rbp), %rax
andl $0x1f, %ecx
movl %ecx, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movl -0x1c(%rbp), %edx
shll %cl, %edx
movl %edx, %ecx
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movzbl 0xa(%rax), %eax
movl %eax, %esi
movl -0x1c(%rbp), %edx
callq 0x10c00
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kchan1[P]helloworld_test1/./encoder.hh
// Function: subordinate_pass(double**, int, IntQueue*, double**, BitWriter*)
void subordinate_pass(double**image,int threshold,IntQueue*sub_list,double**recon_coeff,BitWriter*bitstream)
{
  int coord,x,y;
  //empty out the sub_list
  while(sub_list->size>0)
  {
    //separate x and y from the compact form used in the list
    coord = sub_list->DQ();
    x=coord>>16&0xFFFF;
    y=coord&0xFFFF;
    //as in the algorithm
    if(image[x][y]>recon_coeff[x][y])
    {
      bitstream->write(1);
      recon_coeff[x][y]+=threshold/2;
    }
    else
    {
      bitstream->write(0);
      recon_coeff[x][y]-=threshold/2;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jbe 0x2fa0
movq -0x18(%rbp), %rdi
callq 0x6650
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
sarl $0x10, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x2f63
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x6580
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cvtsi2sd %eax, %xmm0
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x2f9b
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x6580
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cvtsi2sd %eax, %xmm1
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x2ecb
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kchan1[P]helloworld_test1/./encoder.hh
// Function: BitWriter::write(unsigned char)
void write(unsigned char bit)
  {
    //add the new bit to the buffer
    buffer = buffer | (bit&1)<<(7-bitnum++);
    //we only write to the stream when 8 bits have been written
    if(bitnum==8)
    {
      *out<<buffer;
      bitnum=0;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzbl 0x8(%rax), %ecx
movl %ecx, -0x10(%rbp)
movzbl -0x9(%rbp), %edx
andl $0x1, %edx
movl 0xc(%rax), %esi
movl %esi, %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movl $0x7, %ecx
subl %esi, %ecx
shll %cl, %edx
movl -0x10(%rbp), %ecx
orl %edx, %ecx
movb %cl, 0x8(%rax)
cmpl $0x8, 0xc(%rax)
jne 0x65e5
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movzbl 0x8(%rax), %esi
callq 0x2280
movq -0x18(%rbp), %rax
movl $0x0, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kchan1[P]helloworld_test1/./encoder.hh
// Function: IntQueue::NQ(int)
bool NQ(int i)
  {
    if( size != cap )
    {
      size++;
      //std::cout<<"\tNQ:" << i <<"|" << size << "/" << cap <<  "\n";
      q[end] = i;
      end = (end+1)%cap;
      return true;
    }
    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
je 0x663b
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx)
movl -0x14(%rbp), %esi
movq 0x10(%rcx), %rax
movl 0xc(%rcx), %edx
movl %esi, (%rax,%rdx,4)
movl 0xc(%rcx), %eax
addl $0x1, %eax
xorl %edx, %edx
divl (%rcx)
movq -0x20(%rbp), %rax
movl %edx, 0xc(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x663f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kchan1[P]helloworld_test1/./encoder.hh
// Function: IntQueue::DQ()
int DQ()
  {
    if(size != 0)
    {
      int ret;
      size--;
      ret = q[start];
      start = (start+1)%cap;
      //std::cout<<"\tDQ:" << ret <<"|" << size<< "/" << cap << "\n";
      return ret;
    }
    return -1;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x4(%rax)
je 0x6699
movq -0x20(%rbp), %rcx
movl 0x4(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rcx)
movq 0x10(%rcx), %rax
movl 0x8(%rcx), %edx
movl (%rax,%rdx,4), %eax
movl %eax, -0x14(%rbp)
movl 0x8(%rcx), %eax
addl $0x1, %eax
xorl %edx, %edx
divl (%rcx)
movq -0x20(%rbp), %rax
movl %edx, 0x8(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x66a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: kchan1[P]helloworld_test1/./encoder.hh
// Function: IntQueue::IntQueue(unsigned int)
IntQueue(unsigned int capacity)
  {
    q = (int*)(calloc(capacity,sizeof(int)));
    cap = capacity;
    size = 0;
    start = 0;
    end = 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %edi
movl $0x4, %esi
callq 0x2100
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: TrierTableau(int*, int)
void TrierTableau(int tableau[],int taille){

	int i, inversion,tmp;
	do
	{
		inversion=0;

		for(i=1;i<taille;i++)
		{
			if (tableau[i]>tableau[i+1])
			{
				tmp = tableau[i];
				tableau[i] = tableau[i+1];
				tableau[i+1] = tmp;
				inversion=1;
			}
		}
	}
	while(inversion);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x27be
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0x10(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x27b1
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl $0x1, -0x14(%rbp)
jmp 0x27b3
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2749
jmp 0x27c0
cmpl $0x0, -0x14(%rbp)
jne 0x273b
popq %rbp
retq
nopl (%rax)
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: vecteursEgaux(DescTree, DescTree)
int vecteursEgaux(struct DescTree DTSpecies, struct DescTree DTGene){

	int Tspecies = DTSpecies.nbSommet;
	int Tgene = DTGene.nbSommet;
	int i;

	if(Tspecies != Tgene) return 0;

	for(i=1;i<=Tspecies;i++)
		if(DTSpecies.Tableau[i] != DTGene.Tableau[i])
			return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl (%rcx), %ecx
movl %ecx, -0x8(%rbp)
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x27ff
movl $0x0, -0x4(%rbp)
jmp 0x284b
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x2844
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rdx
movl (%rax,%rdx,4), %eax
movq 0x10(%rcx), %rcx
movslq -0x10(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x2837
movl $0x0, -0x4(%rbp)
jmp 0x284b
jmp 0x2839
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2806
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: Floyd(double**, double**, int, int)
void Floyd(double ** Adjacence , double ** DIST,int n,int kt)
{
	int i,j,k;

	for(i=1;i<=2*n-2-kt;i++)
		for(j=1;j<=2*n-2-kt;j++)
		{
			if(i==j)
				DIST[i][j] = 0;
			else
				DIST[i][j] = Adjacence[i][j];
		}

		for(i=1;i<=2*n-2-kt;i++)
			for(j=1;j<=2*n-2-kt;j++)
				for(k=1;k<=2*n-2-kt;k++)
				{
					if((DIST[j][i] + DIST[i][k]) < DIST[j][k])
						DIST[j][k] = DIST[j][i] + DIST[i][k];
				}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
subl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jg 0x2901
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
subl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jg 0x28f1
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x28ba
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
jmp 0x28e4
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x28e6
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2886
jmp 0x28f3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2869
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
subl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jg 0x2a0c
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
subl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jg 0x29fc
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
subl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jg 0x29ec
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x29dc
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x29de
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2942
jmp 0x29ee
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2925
jmp 0x29fe
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2908
popq %rbp
retq
nop
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: loadAdjacenceMatrix(double**, long*, double*, int, int)
void loadAdjacenceMatrix( double **Adjacence, long int *ARETE, double *LONGUEUR,int size,int kt){
	
	int i,j;
	
	for(i=1;i<=2*size-2;i++) /*/(n+1)*/
		for(j=1;j<=2*size-2;j++){
			Adjacence[i][j] = Adjacence[j][i] = INFINI;
      //printf("i=%d,j=%d",i,j);
}
	for(i=1;i<=2*size-3-kt;i++){
		Adjacence[ARETE[2*i-2]][ARETE[2*i-1]] = LONGUEUR[i-1];//(LONGUEUR[i-1]>5*epsilon)?LONGUEUR[i-1]:5*epsilon;
		Adjacence[ARETE[2*i-1]][ARETE[2*i-2]] = LONGUEUR[i-1]; //(LONGUEUR[i-1]>5*epsilon)?LONGUEUR[i-1]:5*epsilon;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x1c(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jg 0x32c5
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl -0x1c(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jg 0x32b8
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x24(%rbp), %rcx
movsd 0x21d9d(%rip), %xmm0    # 0x25028
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd 0x21d80(%rip), %xmm0    # 0x25028
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3264
jmp 0x32ba
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x324e
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x1c(%rbp), %ecx
shll %ecx
subl $0x3, %ecx
subl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jg 0x337a
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x24(%rbp), %edx
shll %edx
subl $0x2, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movl -0x24(%rbp), %edx
shll %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x24(%rbp), %edx
shll %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movl -0x24(%rbp), %edx
shll %edx
subl $0x2, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x32cc
popq %rbp
retq
nopl (%rax)
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: Table_Comparaison(int**, int**, int*, int*, int, int, int)
int Table_Comparaison (int **B, int ** B1, int *PLACE, int *PLACE1, int m, int m1,int n)
{
	int RF=0,i,p,p1;

	p=1; p1=1;

	while ((p<=m)&&(p1<=m1))
	{
		i=n;
		while ((B[PLACE[p]][i]==B1[PLACE1[p1]][i])&&(i>1))
			i--;
		if (i==1) { RF=RF+1; p++; p1++; }
		else if (B[PLACE[p]][i]>B1[PLACE1[p1]][i]) p1++;
		else p++; 

	}
	RF=(m-RF)+(m1-RF);

	return RF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x1, -0x34(%rbp)
movl $0x1, -0x38(%rbp)
movl -0x34(%rbp), %ecx
xorl %eax, %eax
cmpl -0x24(%rbp), %ecx
movb %al, -0x39(%rbp)
jg 0x4a0d
movl -0x38(%rbp), %eax
cmpl -0x28(%rbp), %eax
setle %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x4a19
jmp 0x4af0
movl 0x10(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x34(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rdx
movslq -0x38(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movq (%rax,%rdx,8), %rdx
movslq -0x30(%rbp), %rsi
xorl %eax, %eax
cmpl (%rdx,%rsi,4), %ecx
movb %al, -0x3a(%rbp)
jne 0x4a66
cmpl $0x1, -0x30(%rbp)
setg %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x4a6f
jmp 0x4a7a
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4a1f
cmpl $0x1, -0x30(%rbp)
jne 0x4a9d
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4aeb
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x34(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movslq -0x38(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x30(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x4ae0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x4ae9
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4aeb
jmp 0x49f4
movl -0x24(%rbp), %eax
subl -0x2c(%rbp), %eax
movl -0x28(%rbp), %ecx
subl -0x2c(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: findFils(double**, int, int)
int findFils(double ** Adjacence,int sommet,int n){

	int i;
	
	for(i=1;i<=2*n-2;i++){
		if(Adjacence[sommet][i]<INFINI){
			Adjacence[sommet][i] = Adjacence[i][sommet] = INFINI;
			return i;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x18(%rbp), %ecx
shll %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jg 0x7eb2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd 0x1d1cc(%rip), %xmm0    # 0x25028
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x7ea5
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movsd 0x1d1ad(%rip), %xmm0    # 0x25028
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movsd 0x1d190(%rip), %xmm0    # 0x25028
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7eb9
jmp 0x7ea7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7e35
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: CreerSousArbre(long*, int*, double**, int, int)
struct TNoeud * CreerSousArbre(long int *ARETE,int *indice, double ** Adjacence,int sommet,int n){

	int i=0;
	int *tableau;
	int nbElt=0;
	int nouveauFils;
	struct TNoeud * node;

	if(sommet==-1)
		return NULL;

	tableau = (int*)malloc(100*sizeof(int));

	node = (struct TNoeud*)malloc(sizeof(struct TNoeud));
	node->NoNoeud = sommet;
	node->nbfils = 0;
	node->fils = (struct TNoeud**)malloc(100*sizeof(struct TNoeud*));
	for(i=0;i<100;i++)
		node->fils[i] = NULL;

	nouveauFils = -1;

	do{
		nouveauFils = findFils(Adjacence,sommet,n);
		if(nouveauFils != -1){
			tableau[nbElt] = nouveauFils;
			nbElt++;
		}
	}while(nouveauFils != -1);

	for(i=0;i<nbElt;i++){	
		node->fils[node->nbfils] = CreerSousArbre(ARETE,indice,Adjacence,tableau[i],n);
		node->nbfils = node->nbfils + 1;
	}
	free(tableau);
	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x7efc
movq $0x0, -0x8(%rbp)
jmp 0x801e
movl $0x190, %edi            # imm = 0x190
callq 0x1110
movq %rax, -0x38(%rbp)
movl $0x18, %edi
callq 0x1110
movq %rax, -0x48(%rbp)
movl -0x24(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, (%rax)
movq -0x48(%rbp), %rax
movl $0x0, 0x10(%rax)
movl $0x320, %edi            # imm = 0x320
callq 0x1110
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x2c(%rbp)
cmpl $0x64, -0x2c(%rbp)
jge 0x7f6d
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7f48
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x7e20
movl %eax, -0x40(%rbp)
cmpl $-0x1, -0x40(%rbp)
je 0x7fa3
movl -0x40(%rbp), %edx
movq -0x38(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x7fa5
cmpl $-0x1, -0x40(%rbp)
jne 0x7f74
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x800d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movl -0x28(%rbp), %r8d
callq 0x7ec0
movq %rax, %rdx
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x48(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x48(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7fb2
movq -0x38(%rbp), %rdi
callq 0x10e0
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: sortIntTab(int*, int, int)
void sortIntTab(int * tab, int debut, int fin){
	
	int i,j,tmp;

	for(i=debut;i<=fin;i++){
		for(j=i+1;j<=fin;j++){
			if(tab[i] > tab[j]){
				tmp = tab[i];
				tab[i] = tab[j];
				tab[j] = tmp;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x80c1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x80b4
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movslq -0x18(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x80a7
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x80a9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8055
jmp 0x80b6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8044
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: viderArbre(TNoeud*)
void viderArbre(struct TNoeud * A){
	int i;
	
	if(A->nbfils != 0){
		for(i=0; i<A->nbfils;i++){
			viderArbre(A->fils[i]);
		}
	//	printf("%d ",A->NoNoeud);
		free(A->fils);
		free(A);
	}
	else{
		free(A->fils);
		free(A);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x8371
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x8359
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8310
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x832d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rdi
callq 0x10e0
jmp 0x8387
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rdi
callq 0x10e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: AfficherArbre(TNoeud*, int)
void AfficherArbre(struct TNoeud * A,int prof){
	
	int i, taille;
	
	if(A != NULL){
		if(A->nbfils== 0){
			for(i=0;i<prof;i++) printf("  ");
			printf("%d\n",A->NoNoeud);
		}
		else{
			taille = A->nbfils;
			for(i=0; i<taille/2;i++){
				AfficherArbre(A->fils[i],prof+1);
				printf("\n");
			}
			for(i=0;i<prof;i++) printf("  ");
			printf("%d\n",A->NoNoeud);
			for(i=taille/2; i<taille;i++){
				AfficherArbre(A->fils[i],prof+1);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x84d0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x83f5
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x83dc
leaq 0x1d0cc(%rip), %rdi     # 0x25496
movb $0x0, %al
callq 0x1030
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x83bb
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0x1d0b0(%rip), %rdi     # 0x25499
movb $0x0, %al
callq 0x1030
jmp 0x84ce
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jge 0x8454
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x8390
leaq 0x1ddb5(%rip), %rdi     # 0x261f7
movb $0x0, %al
callq 0x1030
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8406
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x847c
leaq 0x1d02c(%rip), %rdi     # 0x25496
movb $0x0, %al
callq 0x1030
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x845b
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0x1d010(%rip), %rdi     # 0x25499
movb $0x0, %al
callq 0x1030
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x84cc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x8390
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x849e
jmp 0x84ce
jmp 0x84d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dcarrey[P]hgt-detection/./utils_tree.cpp
// Function: itoa_(int, char*, int)
char * itoa_(int val,char *buf,int radix){
	if (radix == 10 && val < 0)
		xtoa((unsigned long)val, buf, radix, 1);
	else
		xtoa((unsigned long)(unsigned int)val, buf, radix, 0);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jne 0x8905
cmpl $0x0, -0x4(%rbp)
jge 0x8905
movslq -0x4(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl $0x1, %ecx
callq 0x8930
jmp 0x8918
movl -0x4(%rbp), %eax
movl %eax, %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
xorl %ecx, %ecx
callq 0x8930
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)