LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: klyushinmisha[P]GBEmu/./src/Memory.cpp
// Function: Memory::Read(int)
byte Memory::Read(int addr)
{
    gb->Sync();
    
    
    //Reads from ROM
    if (isBooting & (addr < 256))
    {
        return ROM[addr];
    }

    //Reads from external RAM
    if ((addr > 0x9FFF) & (addr < 0xBFFF) & (RAMBank != 0))
        return cartridgeData[RAMBank - 1][addr - 0x8000];

    //Reads from RAM
    int x = RAM[addr];
    
    if (addr >= 0xC192 && addr < 0xC200)
        x = x;
    
    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rdi
callq 0x30c0
movq -0x20(%rbp), %rax
movb 0x1a(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x9299
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x9330
movq -0x20(%rbp), %rcx
cmpl $0x9fff, -0x14(%rbp)    # imm = 0x9FFF
setg %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0xbfff, -0x14(%rbp)    # imm = 0xBFFF
setl %dl
andb $0x1, %dl
movzbl %dl, %edx
andl %edx, %eax
movzbl 0x1d(%rcx), %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x92ff
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rax
movzbl 0x1d(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rbp), %ecx
subl $0x8000, %ecx           # imm = 0x8000
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x9330
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
cmpl $0xc192, -0x14(%rbp)    # imm = 0xC192
jl 0x932a
cmpl $0xc200, -0x14(%rbp)    # imm = 0xC200
jge 0x932a
movl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: klyushinmisha[P]GBEmu/./src/Memory.cpp
// Function: Memory::ReadWord(int)
ushort Memory::ReadWord(int addr)
{
    ushort temp;
    temp = Read(addr + 1);
    temp <<= 8;
    temp |= Read(addr);
    return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x9240
movq -0x18(%rbp), %rdi
movzbl %al, %eax
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
shll $0x8, %eax
movw %ax, -0xe(%rbp)
movl -0xc(%rbp), %esi
callq 0x9240
movzbl %al, %ecx
movzwl -0xe(%rbp), %eax
orl %ecx, %eax
movw %ax, -0xe(%rbp)
movw -0xe(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: klyushinmisha[P]GBEmu/./src/Timer.cpp
// Function: Timer::Inc()
void Timer::Inc()
{
    //Syncronization of DIV register
    systemCounter += 4;
    if (systemCounter == 0)
        //DIV
        RAM[0xFF04]++;
   
    //Checks timer (enabled or not)
    enabled = (RAM[0xFF07] & 4) == 4;

    //Sets timer frequency
    switch (RAM[0xFF07] & 3)
    {
        case 0:
            frequency = 1024;
            break;
        case 1:
            frequency = 16;
            break;
        case 2:
            frequency = 64;
            break;
        case 4:
            frequency = 256;
            break;
    }

    if (enabled) {
        //Syncronization of TIMA register
        internalCounter += 4;
        if (internalCounter == frequency) {
            //TIMA
            RAM[0xFF05]++;
            //Checks TIMA overflow
            if (RAM[0xFF05] == 0)
            {
                //copy TMA to TIMA
                RAM[0xFF05] = RAM[0xFF06];
                RAM[0xFF0F] |= 4;
            }
        }
        internalCounter = internalCounter % frequency;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movzbl (%rax), %ecx
addl $0x4, %ecx
movb %cl, (%rax)
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x9707
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movb 0xff04(%rax), %cl
addb $0x1, %cl
movb %cl, 0xff04(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movzbl 0xff07(%rcx), %ecx
andl $0x4, %ecx
shrl $0x2, %ecx
movb %cl, 0x10(%rax)
movq 0x8(%rax), %rax
movzbl 0xff07(%rax), %eax
andl $0x3, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4, %eax
ja 0x977e
movq -0x18(%rbp), %rax
leaq 0x2225(%rip), %rcx      # 0xb968
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movl $0x400, 0x14(%rax)      # imm = 0x400
jmp 0x977e
movq -0x10(%rbp), %rax
movl $0x10, 0x14(%rax)
jmp 0x977e
movq -0x10(%rbp), %rax
movl $0x40, 0x14(%rax)
jmp 0x977e
movq -0x10(%rbp), %rax
movl $0x100, 0x14(%rax)      # imm = 0x100
movq -0x10(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x9804
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %eax
addl $0x4, %eax
movl %eax, 0x4(%rcx)
movl 0x4(%rcx), %eax
cmpl 0x14(%rcx), %eax
jne 0x97f2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movb 0xff05(%rcx), %dl
addb $0x1, %dl
movb %dl, 0xff05(%rcx)
movq 0x8(%rax), %rax
movzbl 0xff05(%rax), %eax
cmpl $0x0, %eax
jne 0x97f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movb 0xff06(%rcx), %dl
movq 0x8(%rax), %rcx
movb %dl, 0xff05(%rcx)
movq 0x8(%rax), %rax
movzbl 0xff0f(%rax), %ecx
orl $0x4, %ecx
movb %cl, 0xff0f(%rax)
jmp 0x97f2
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %eax
cltd
idivl 0x14(%rcx)
movq -0x10(%rbp), %rax
movl %edx, 0x4(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: klyushinmisha[P]GBEmu/./src/Interrupts.cpp
// Function: Interrupts::Interrupts()
Interrupts::Interrupts()
{
    interruptCounter = 0;
    this->gb = GameBoy::getInstance();
    this->RAM = gb->getRAM();
    gb->Halt = false; gb->Stop = false;
    gb->IME = true;
    gb->DMATransfer = false;
    IE = RAM + 0xFFFF;
    IF = RAM + 0xFF0F;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, 0x10(%rax)
callq 0x2990
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x88e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq (%rax), %rcx
movb $0x0, 0x5a(%rcx)
movq (%rax), %rcx
movb $0x0, 0x5b(%rcx)
movq (%rax), %rcx
movb $0x1, 0x59(%rcx)
movq (%rax), %rcx
movb $0x0, 0x58(%rcx)
movq 0x8(%rax), %rcx
addq $0xffff, %rcx           # imm = 0xFFFF
movq %rcx, 0x18(%rax)
movq 0x8(%rax), %rcx
addq $0xff0f, %rcx           # imm = 0xFF0F
movq %rcx, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: klyushinmisha[P]GBEmu/./src/Interrupts.cpp
// Function: Interrupts::Manager()
void Interrupts::Manager()
{
    if (gb->Stop)
        return;
    if ((*IE & *IF) != 0)
    {
        gb->Halt = false;
        if (gb->IME)
        {
            gb->IME = false;
            byte interrupts = (byte)(*IE & *IF);
            byte interrupt = 0;
            *IF &= (byte)(~interrupts);
            while (((interrupts >> interrupt) & 1) != 1)
                interrupt++;
            switch (interrupt)
            {
                case 0:
                    gb->Interrupt(0x40);
                    break;
                case 1:
                    gb->Interrupt(0x48);
                    break;
                case 2:
                    gb->Interrupt(0x50);
                    break;
                case 4:
                    gb->Interrupt(0x60);
                    break;
            }
        }
    }

    if (gb->Halt)
        gb->Sync();
    else
        gb->Clock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
testb $0x1, 0x5b(%rax)
je 0x98d2
jmp 0x99f1
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rax
movzbl (%rax), %eax
movq 0x20(%rcx), %rcx
movzbl (%rcx), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x99ca
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movb $0x0, 0x5a(%rcx)
movq (%rax), %rax
testb $0x1, 0x59(%rax)
je 0x99c8
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movb $0x0, 0x59(%rcx)
movq 0x18(%rax), %rcx
movzbl (%rcx), %ecx
movq 0x20(%rax), %rdx
movzbl (%rdx), %edx
andl %edx, %ecx
movb %cl, -0x9(%rbp)
movb $0x0, -0xa(%rbp)
movzbl -0x9(%rbp), %ecx
xorl $-0x1, %ecx
movzbl %cl, %edx
movq 0x20(%rax), %rax
movzbl (%rax), %ecx
andl %edx, %ecx
movb %cl, (%rax)
movzbl -0x9(%rbp), %eax
movzbl -0xa(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
cmpl $0x1, %eax
je 0x995a
movb -0xa(%rbp), %al
addb $0x1, %al
movb %al, -0xa(%rbp)
jmp 0x993e
movzbl -0xa(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x4, %rax
ja 0x99c6
movq -0x20(%rbp), %rax
leaq 0x2009(%rip), %rcx      # 0xb97c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x40, %esi
callq 0x3260
jmp 0x99c6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x48, %esi
callq 0x3260
jmp 0x99c6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x50, %esi
callq 0x3260
jmp 0x99c6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x60, %esi
callq 0x3260
jmp 0x99c8
jmp 0x99ca
movq -0x18(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x5a(%rax)
je 0x99e5
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x30c0
jmp 0x99f1
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3290
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: klyushinmisha[P]GBEmu/./src/Interrupts.cpp
// Function: Interrupts::EnterHALTMode()
bool Interrupts::EnterHALTMode() {
    gb->Halt = true;
    if (gb->IME && !(*IE & *IF)) {
        gb->Halt = false;
    }
    return gb->Halt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rcx
movb $0x1, 0x5a(%rcx)
movq (%rax), %rax
testb $0x1, 0x59(%rax)
je 0x9d84
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rax
movzbl (%rax), %eax
movq 0x20(%rcx), %rcx
movzbl (%rcx), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x9d84
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, 0x5a(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb 0x5a(%rax), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: klyushinmisha[P]GBEmu/./src/main.cpp
// Function: main
int main(int argc, char** argv)
{
	GameBoy* gb = GameBoy::getInstance();
	gb->LoadCartridge(argv[1]);
    gb->Run();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2990
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x23c0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x9f50
jmp 0x9ee3
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2ac0
jmp 0x9ef2
leaq -0x38(%rbp), %rdi
callq 0x2160
leaq -0x39(%rbp), %rdi
callq 0x2290
movq -0x18(%rbp), %rdi
callq 0x2b30
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x9f38
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2160
leaq -0x39(%rbp), %rdi
callq 0x2290
movq -0x48(%rbp), %rdi
callq 0x23b0
nopw (%rax,%rax)
// File: PrzemekWirkus[P]functional-workshop/src/utest.h
// Function: bool CHECK_EQUAL<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool CHECK_EQUAL(const char *str, T1 t1, T2 t2) {
    using namespace std;

    bool result = true;
    if (__NOT equal(begin(t1), end(t1), begin(t2))) {
        auto mypair = 
            mismatch(begin(t1), end(t1), begin(t2));
        cout << __FILE__ << ": Array mismatch: " << endl;
        for_each(begin(t1), end(t1), [] (typename T1::value_type i) { cout << i << " "; });
        cout << endl;
        for_each(begin(t2), end(t2), [] (typename T1::value_type i) { cout << i << " "; });
        cout << endl;
        result = false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, %rax
movq -0xa8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq %rdx, -0x98(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
callq 0x1800
movq -0xa0(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x1830
movq -0x98(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x1800
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x17b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x164f
jmp 0x1753
movq -0xa0(%rbp), %rdi
callq 0x1800
movq -0xa0(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x1830
movq -0x98(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x1800
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x1860
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq 0x2939(%rip), %rdi      # 0x3fd8
leaq 0x95e(%rip), %rsi       # 0x2004
callq 0x1070
movq %rax, %rdi
leaq 0x9f8(%rip), %rsi       # 0x20ad
callq 0x1070
movq %rax, %rdi
movq 0x28fc(%rip), %rsi      # 0x3fc0
callq 0x1080
movq -0xa0(%rbp), %rdi
callq 0x1800
movq -0xa0(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x1830
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x18c0
movq 0x28db(%rip), %rdi      # 0x3fd8
movq 0x28bc(%rip), %rsi      # 0x3fc0
callq 0x1080
movq -0x98(%rbp), %rdi
callq 0x1800
movq -0x98(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x1830
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x1910
movq 0x2895(%rip), %rdi      # 0x3fd8
movq 0x2876(%rip), %rsi      # 0x3fc0
callq 0x1080
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rsi
movq 0x287a(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0x8bb(%rip), %rsi       # 0x2028
callq 0x1070
movq %rax, %rdi
movb -0x19(%rbp), %cl
leaq 0x8ae(%rip), %rsi       # 0x202d
leaq 0x8a4(%rip), %rax       # 0x202a
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x1070
movq %rax, %rdi
movq 0x2824(%rip), %rsi      # 0x3fc0
callq 0x1080
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nop
// File: eschwabe[P]interview-practice/src/libds_btree.cpp
// Function: BinaryTree::Insert(int const&)
void BinaryTree::Insert(const int& value) {
  if(!root_) {
    root_.reset(new Node());
    root_->value = value;
    return;
  }
  Node* current = root_.get();
  while(current != nullptr) {
    if(current->value >= value) {
      if(!current->left) {
        current->left.reset(new Node());
        current->left->value = value;
        break;
      }
      current = current->left.get();
    } else {
      if(!current->right) {
        current->right.reset(new Node());
        current->right->value = value;
        break;
      }
      current = current->right.get();
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x1cd0
testb $0x1, %al
jne 0x12e1
movl $0x18, %edi
callq 0x1080
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x1050
movq -0x30(%rbp), %rdi
callq 0x1d30
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x1d00
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
callq 0x1d60
movl -0x24(%rbp), %ecx
movl %ecx, 0x10(%rax)
jmp 0x1400
movq -0x20(%rbp), %rdi
callq 0x1d80
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1400
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x137c
movq -0x18(%rbp), %rdi
callq 0x1cd0
testb $0x1, %al
jne 0x136d
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x18, %edi
callq 0x1080
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x1050
movq -0x40(%rbp), %rdi
callq 0x1d30
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x1d00
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d60
movl -0x34(%rbp), %ecx
movl %ecx, 0x10(%rax)
jmp 0x1400
movq -0x18(%rbp), %rdi
callq 0x1d80
movq %rax, -0x18(%rbp)
jmp 0x13fb
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x1cd0
testb $0x1, %al
jne 0x13ea
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x60(%rbp)
movl $0x18, %edi
callq 0x1080
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x1050
movq -0x58(%rbp), %rdi
callq 0x1d30
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x1d00
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d60
movl -0x4c(%rbp), %ecx
movl %ecx, 0x10(%rax)
jmp 0x1400
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d80
movq %rax, -0x18(%rbp)
jmp 0x12ee
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: eschwabe[P]interview-practice/src/libds_btree.cpp
// Function: BinaryTree::InsertNode(std::unique_ptr<BinaryTree::Node, std::default_delete<BinaryTree::Node>>&)
void BinaryTree::InsertNode(NodePtr& ptr) {
  if(!ptr) {
    return;
  }
  if(!root_) {
    root_ = std::move(ptr);
    return;
  }
  Node* current = root_.get();
  while(current != nullptr) {
    if(current->value >= ptr->value) {
      if(!current->left) {
        current->left = std::move(ptr);
        break;
      }
      current = current->left.get();
    } else {
      if(!current->right) {
        current->right = std::move(ptr);
        break;
      }
      current = current->right.get();
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1cd0
testb $0x1, %al
jne 0x143a
jmp 0x14f4
movq -0x20(%rbp), %rdi
callq 0x1cd0
testb $0x1, %al
jne 0x1459
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1db0
jmp 0x14f4
movq -0x20(%rbp), %rdi
callq 0x1d80
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x14f4
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d60
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl 0x10(%rcx), %eax
jl 0x14ba
movq -0x18(%rbp), %rdi
callq 0x1cd0
testb $0x1, %al
jne 0x14ab
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x1db0
jmp 0x14f4
movq -0x18(%rbp), %rdi
callq 0x1d80
movq %rax, -0x18(%rbp)
jmp 0x14ef
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x1cd0
testb $0x1, %al
jne 0x14de
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x1db0
jmp 0x14f4
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d80
movq %rax, -0x18(%rbp)
jmp 0x1466
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: eschwabe[P]interview-practice/src/libds_btree.cpp
// Function: BinaryTree::Remove(int const&)
bool BinaryTree::Remove(const int& value) {
  Node* current = root_.get();
  if(current->value == value) {
    NodePtr right_tmp(std::move(current->right));
    root_ = std::move(current->left);
    InsertNode(right_tmp);
    return true;
  }
  while(current != nullptr) {
    if(current->value >= value) {
      if(current->left && current->left->value == value) {
        NodePtr right_tmp(std::move(current->left->right));
        current->left = std::move(current->left->left);
        InsertNode(right_tmp);
        return true;
      }
      current = current->left.get();
    } else {
      if(current->right && current->right->value == value) {
        NodePtr right_tmp(std::move(current->right->right));
        current->right = std::move(current->right->left);
        InsertNode(right_tmp);
        return true;
      }
      current = current->right.get();
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1d80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x156d
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x1de0
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1db0
movq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1410
movb $0x1, -0x1(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1c80
jmp 0x16aa
jmp 0x156f
cmpq $0x0, -0x20(%rbp)
je 0x16a6
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x160f
movq -0x20(%rbp), %rdi
callq 0x1cd0
testb $0x1, %al
jne 0x159c
jmp 0x15fd
movq -0x20(%rbp), %rdi
callq 0x1d60
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x15fd
movq -0x20(%rbp), %rdi
callq 0x1d60
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
callq 0x1de0
movq -0x20(%rbp), %rdi
callq 0x1d60
movq %rax, %rsi
movq -0x20(%rbp), %rdi
callq 0x1db0
movq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1410
movb $0x1, -0x1(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c80
jmp 0x16aa
movq -0x20(%rbp), %rdi
callq 0x1d80
movq %rax, -0x20(%rbp)
jmp 0x16a1
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1cd0
testb $0x1, %al
jne 0x1622
jmp 0x1690
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d60
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1690
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d60
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
callq 0x1de0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d60
movq %rax, %rsi
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1db0
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1410
movb $0x1, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c80
jmp 0x16aa
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d80
movq %rax, -0x20(%rbp)
jmp 0x156f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: eschwabe[P]interview-practice/src/libds_btree.cpp
// Function: BinaryTree::Find(int const&)
bool BinaryTree::Find(const int& value) {
  Node* current = root_.get();
  while(current != nullptr) {
    if(current->value == value) {
      return true;
    }
    else if(current->value >= value) {
      current = current->left.get();
    } else {
      current = current->right.get();
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d80
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x172c
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x16f9
movb $0x1, -0x1(%rbp)
jmp 0x1730
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x1717
movq -0x20(%rbp), %rdi
callq 0x1d80
movq %rax, -0x20(%rbp)
jmp 0x1728
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d80
movq %rax, -0x20(%rbp)
jmp 0x172a
jmp 0x16dd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: eschwabe[P]interview-practice/src/libds_btree.cpp
// Function: BinaryTree::PrintPreOrder(BinaryTree::Node*, std::ostream&)
void BinaryTree::PrintPreOrder(Node* root, std::ostream& stream) {
  if(root) {
    PrintPreOrder(root->left.get(), stream);
    stream << root->value << " ";
    PrintPreOrder(root->right.get(), stream);
  }
}

// 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)
cmpq $0x0, -0x10(%rbp)
je 0x1808
movq -0x10(%rbp), %rdi
callq 0x1d80
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x1790
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x10c0
movq %rax, %rdi
leaq 0x1827(%rip), %rsi      # 0x300d
callq 0x1070
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d80
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x1790
addq $0x20, %rsp
popq %rbp
retq
nop
// File: kdungs[P]codecon/src/base_arithmetic.cc
// Function: findBase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto findBase(const std::string& str) noexcept -> int {
  return charToDigit(
      *std::max_element(std::begin(str), std::end(str), [](char lhs, char rhs) {
        return charToDigit(lhs) < charToDigit(rhs);
      })) + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15f0
movq %rax, -0x30(%rbp)
jmp 0x12fb
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1630
movq %rax, -0x38(%rbp)
jmp 0x1312
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1360
movq %rax, -0x40(%rbp)
jmp 0x132d
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1660
movsbl (%rax), %edi
callq 0x12a0
addl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1620
nopw (%rax,%rax)
// File: kdungs[P]codecon/src/base_arithmetic.cc
// Function: main
int main() {
  auto line = std::string{};
  getline(std::cin, line);
  auto x = bestConversion(line);
  getline(std::cin, line);
  auto y = bestConversion(line);
  std::cout << x + y << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x10e0
movq -0x48(%rbp), %rsi
movq 0x2be0(%rip), %rdi      # 0x3fe0
callq 0x1040
jmp 0x1407
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x13a0
movq -0x50(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq 0x2bbd(%rip), %rdi      # 0x3fe0
callq 0x1040
jmp 0x142a
leaq -0x20(%rbp), %rdi
callq 0x13a0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rax
addq %rax, %rsi
movq 0x2b87(%rip), %rdi      # 0x3fd0
callq 0x1080
movq %rax, -0x58(%rbp)
jmp 0x1454
movq -0x58(%rbp), %rdi
movl $0xa, %esi
callq 0x10d0
jmp 0x1464
leaq -0x20(%rbp), %rdi
callq 0x10a0
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x10a0
movq -0x28(%rbp), %rdi
callq 0x1110
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/./Blob.h
// Function: std::ostream& operator<<<int>(std::ostream&, Blob<int>)
std::ostream& operator<<(std::ostream &os, const Blob<T> a)
{
	os << "< ";
	for (size_t i = 0; i < a.size(); ++i)
		os << a[i] << " ";
	os << " >";
	return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9e61(%rip), %rsi      # 0xd110
callq 0x20f0
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x33f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x3316
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x65d0
movq -0x30(%rbp), %rdi
movl (%rax), %esi
callq 0x21c0
movq %rax, %rdi
leaq 0x9e0e(%rip), %rsi      # 0xd111
callq 0x20f0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x32bc
movq -0x8(%rbp), %rdi
leaq 0x9df2(%rip), %rsi      # 0xd113
callq 0x20f0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: siolag161[P]louvain-original/graph_binary.cpp
// Function: Graph::display()
void
Graph::display() {
/*  for (unsigned int node=0 ; node<nb_nodes ; node++) {
    pair<vector<unsigned int>::iterator, vector<float>::iterator > p = neighbors(node);
    for (unsigned int i=0 ; i<nb_neighbors(node) ; i++) {
      if (node<=*(p.first+i)) {
	if (weights.size()!=0)
	  cout << node << " " << *(p.first+i) << " " << *(p.second+i) << endl;
	else
	  cout << node << " " << *(p.first+i) << endl;
      }
    }   
  }*/
  for (unsigned int node=0 ; node<nb_nodes ; node++) {
    pair<vector<unsigned int>::iterator, vector<float>::iterator > p = neighbors(node);
    cout << node << ":" ;
    for (unsigned int i=0 ; i<nb_neighbors(node) ; i++) {
      if (true) {
	if (weights.size()!=0)
	  cout << " (" << *(p.first+i) << " " << *(p.second+i) << ")";
	else
	  cout << " " << *(p.first+i);
      }
    }
    cout << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x48(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jae 0x2ae4
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x34e0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %esi
movq 0x17638(%rip), %rdi     # 0x19fd0
callq 0x2240
movq %rax, %rdi
leaq 0xe6b1(%rip), %rsi      # 0x11058
callq 0x2190
movl $0x0, -0x24(%rbp)
movq -0x48(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0xc(%rbp), %esi
callq 0x3690
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jae 0x2ac3
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0x3750
cmpq $0x0, %rax
je 0x2a76
movq 0x175e0(%rip), %rdi     # 0x19fd0
leaq 0xe663(%rip), %rsi      # 0x1105a
callq 0x2190
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3770
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x37b0
movq -0x60(%rbp), %rdi
movl (%rax), %esi
callq 0x2240
movq %rax, %rdi
leaq 0xec06(%rip), %rsi      # 0x11636
callq 0x2190
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
addq $0x8, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x37d0
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3810
movq -0x58(%rbp), %rdi
movss (%rax), %xmm0
callq 0x2130
movq %rax, %rdi
leaq 0xe823(%rip), %rsi      # 0x11292
callq 0x2190
jmp 0x2ab3
movq 0x17553(%rip), %rdi     # 0x19fd0
leaq 0xebb2(%rip), %rsi      # 0x11636
callq 0x2190
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3770
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x37b0
movq -0x68(%rbp), %rdi
movl (%rax), %esi
callq 0x2240
jmp 0x2ab5
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x29b3
movq 0x17506(%rip), %rdi     # 0x19fd0
movq 0x174ef(%rip), %rsi     # 0x19fc0
callq 0x21d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x296b
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chlunde[P]qtar/qtar.cc
// Function: Traverser<CScan>::walk(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void walk(std::string& r) {
		root = r;

		struct us_dirent d;
		d.d_ino = -1;
		d.set_is_dir();
		d.parent = root;
		d.d_name = ".";
		d.stat();
		dirheap.push(d);

		while (!dirheap.empty()) {
			d = dirheap.pop();
			heapwalk(d);
		}

		while (!fileheap.empty()) {
			d = fileheap.pop();
			addfile(d);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x3d0(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rdi
callq 0x3030
leaq -0xf8(%rbp), %rdi
movq %rdi, -0x3c8(%rbp)
callq 0x53d0
movq -0x3c8(%rbp), %rdi
movq $-0x1, -0xf8(%rbp)
callq 0x5420
jmp 0x3ad7
movq -0x3d0(%rbp), %rsi
addq $0x8, %rsi
leaq -0xd0(%rbp), %rdi
callq 0x3030
jmp 0x3af0
leaq -0xf0(%rbp), %rdi
leaq 0x9560(%rip), %rsi      # 0xd05e
callq 0x3390
jmp 0x3b05
leaq -0xf8(%rbp), %rdi
callq 0x5440
jmp 0x3b13
movq -0x3d0(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x3d8(%rbp)
leaq -0x1f0(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x5540
jmp 0x3b3a
movq -0x3d8(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x5510
jmp 0x3b4f
leaq -0x1f0(%rbp), %rdi
callq 0x4700
movq -0x3d0(%rbp), %rdi
addq $0x28, %rdi
callq 0x55d0
movb %al, -0x3d9(%rbp)
jmp 0x3b73
movb -0x3d9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3b84
jmp 0x3c1e
movq -0x3d0(%rbp), %rsi
addq $0x28, %rsi
leaq -0x2d8(%rbp), %rdi
callq 0x55f0
jmp 0x3b9d
leaq -0xf8(%rbp), %rdi
movq %rdi, -0x3e8(%rbp)
leaq -0x2d8(%rbp), %rsi
movq %rsi, -0x3f0(%rbp)
callq 0x5870
movq -0x3f0(%rbp), %rdi
callq 0x4700
movq -0x3d0(%rbp), %rdi
movq -0x3e8(%rbp), %rsi
callq 0x58e0
jmp 0x3bdf
jmp 0x3b5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
jmp 0x3cbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x4700
jmp 0x3cbb
jmp 0x3c20
movq -0x3d0(%rbp), %rdi
addq $0x60, %rdi
callq 0x55d0
movb %al, -0x3f1(%rbp)
jmp 0x3c38
movb -0x3f1(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3c46
jmp 0x3ca6
movq -0x3d0(%rbp), %rsi
addq $0x60, %rsi
leaq -0x3c0(%rbp), %rdi
callq 0x55f0
jmp 0x3c5f
leaq -0xf8(%rbp), %rdi
movq %rdi, -0x400(%rbp)
leaq -0x3c0(%rbp), %rsi
movq %rsi, -0x408(%rbp)
callq 0x5870
movq -0x408(%rbp), %rdi
callq 0x4700
movq -0x3d0(%rbp), %rdi
movq -0x400(%rbp), %rsi
callq 0x5d20
jmp 0x3ca1
jmp 0x3c20
leaq -0xf8(%rbp), %rdi
callq 0x4700
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
leaq -0xf8(%rbp), %rdi
callq 0x4700
movq -0x100(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: chlunde[P]qtar/./linux_getdents.h
// Function: us_dirent::stat()
struct stat& stat() {
		if (! st_initialized) {
			std::string name = fq();
			st_initialized = true;
			if (lstat(name.c_str(), &st) < 0)
				err(EXIT_FAILURE, "stat %s failed", name.c_str());
			if (d_ino == 0)
				d_ino = st.st_ino;
		}

		return st;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0xe0(%rax)
jne 0x54ed
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x61b0
movq -0x40(%rbp), %rax
movb $0x1, 0xe0(%rax)
leaq -0x28(%rbp), %rdi
callq 0x3130
movq -0x40(%rbp), %rsi
movq %rax, %rdi
addq $0x50, %rsi
callq 0x34f0
cmpl $0x0, %eax
jge 0x54cf
leaq -0x28(%rbp), %rdi
callq 0x3130
movq %rax, %rdx
leaq 0x7b9b(%rip), %rsi      # 0xd045
xorl %eax, %eax
movl $0x1, %edi
callq 0x3290
jmp 0x54b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31c0
jmp 0x54fb
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x54e4
movq -0x40(%rbp), %rax
movq 0x58(%rax), %rcx
movq %rcx, (%rax)
leaq -0x28(%rbp), %rdi
callq 0x31c0
movq -0x40(%rbp), %rax
addq $0x50, %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
nop
// File: chlunde[P]qtar/qtar.cc
// Function: CScan<us_dirent>::pop()
T pop() {
		typename std::set<T>::iterator it;
		T bound;
		bound.d_ino = last_position;

		it = elevator.lower_bound(bound);
		if (it == elevator.end()) {
			if (last_position == 0)
				throw new std::exception();//"pop on empty queue");
			last_position = 0;
			return pop();
		}

		T ret = *it;
		elevator.erase(it);
		last_position = ret.d_ino;
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6bc0
leaq -0x100(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x53d0
movq -0x150(%rbp), %rdi
movq -0x148(%rbp), %rsi
movq 0x30(%rdi), %rax
movq %rax, -0x100(%rbp)
callq 0x6be0
movq %rax, -0x140(%rbp)
jmp 0x5662
movq -0x150(%rbp), %rdi
movq -0x140(%rbp), %rax
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x6c50
movq %rax, -0x120(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x6c20
testb $0x1, %al
jne 0x56a7
jmp 0x577e
movq -0x150(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x5752
movl $0x8, %edi
movq %rdi, -0x178(%rbp)
callq 0x3160
movq -0x178(%rbp), %rdi
movq %rax, -0x170(%rbp)
callq 0x32b0
movq %rax, -0x168(%rbp)
jmp 0x56e6
movq -0x168(%rbp), %rdi
callq 0x6c80
movq -0x168(%rbp), %rax
movq -0x170(%rbp), %rdi
movq %rax, (%rdi)
leaq 0xd66e(%rip), %rsi      # 0x12d78
xorl %eax, %eax
movl %eax, %edx
callq 0x3460
jmp 0x5867
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0x584f
movq -0x170(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
callq 0x3210
jmp 0x584f
movq -0x150(%rbp), %rsi
movq -0x160(%rbp), %rdi
movq $0x0, 0x30(%rsi)
callq 0x55f0
jmp 0x576f
movl $0x1, -0x124(%rbp)
jmp 0x5833
movb $0x0, -0x125(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6ca0
movq -0x160(%rbp), %rdi
movq %rax, %rsi
callq 0x5540
jmp 0x579f
movq -0x150(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rsi
callq 0x6cc0
movq %rax, -0x180(%rbp)
jmp 0x57c6
movq -0x150(%rbp), %rax
movq -0x160(%rbp), %rcx
movq -0x180(%rbp), %rdx
movq %rdx, -0x138(%rbp)
movq (%rcx), %rcx
movq %rcx, 0x30(%rax)
movb $0x1, -0x125(%rbp)
movl $0x1, -0x124(%rbp)
testb $0x1, -0x125(%rbp)
jne 0x5831
jmp 0x5825
movq -0x160(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
callq 0x4700
jmp 0x584f
movq -0x160(%rbp), %rdi
callq 0x4700
jmp 0x5833
leaq -0x100(%rbp), %rdi
callq 0x4700
movq -0x158(%rbp), %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
leaq -0x100(%rbp), %rdi
callq 0x4700
movq -0x110(%rbp), %rdi
callq 0x3480
nopw (%rax,%rax)
// File: chlunde[P]qtar/qtar.cc
// Function: Traverser<CScan>::lookup_uname[abi:cxx11](unsigned int)
std::string lookup_uname(uid_t uid) {
		std::map<uid_t, std::string>::iterator it = uidcache.find(uid);
		if (it == uidcache.end()) {
			struct passwd *pwent = getpwuid(uid);
			std::string uname;
			if (pwent)
				uname = pwent->pw_name;

			uidcache.insert(std::pair<uid_t, std::string>(uid, uname));

			return uname;
		}

		return (*it).second;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x98, %rdi
leaq -0x14(%rbp), %rsi
callq 0x90a0
movq -0x88(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x98, %rdi
callq 0x9100
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x90d0
testb $0x1, %al
jne 0x8dd3
jmp 0x8ec3
movl -0x14(%rbp), %edi
callq 0x3360
movq -0x98(%rbp), %rdi
movq %rax, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
callq 0x33a0
cmpq $0x0, -0x30(%rbp)
je 0x8e1e
movq -0x98(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0x3390
jmp 0x8e0b
jmp 0x8e1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x8eb5
movq -0x98(%rbp), %rdx
movq -0x88(%rbp), %rax
addq $0x98, %rax
movq %rax, -0xa0(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x9170
jmp 0x8e48
movq -0xa0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x9130
movb %dl, -0xa9(%rbp)
movq %rax, -0xa8(%rbp)
jmp 0x8e67
movb -0xa9(%rbp), %al
movq -0xa8(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movb %al, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x91b0
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x8eb3
jmp 0x8ea7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x91b0
jmp 0x8eb5
movq -0x98(%rbp), %rdi
callq 0x31c0
jmp 0x8edf
movq -0x98(%rbp), %rdi
callq 0x31c0
jmp 0x8eef
leaq -0x20(%rbp), %rdi
callq 0x91d0
movq -0x98(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x3140
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3480
nopl (%rax,%rax)
// File: chlunde[P]qtar/qtar.cc
// Function: Traverser<CScan>::lookup_gname[abi:cxx11](unsigned int)
std::string lookup_gname(gid_t gid) {
		std::map<gid_t, std::string>::iterator it = gidcache.find(gid);
		if (it == gidcache.end()) {
			struct group *grent = getgrgid(gid);
			std::string gname;
			if (grent)
				gname = grent->gr_name;

			gidcache.insert(std::pair<gid_t, std::string>(gid, gname));

			return gname;
		}

		return (*it).second;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0xc8, %rdi
leaq -0x14(%rbp), %rsi
callq 0x90a0
movq -0x88(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0xc8, %rdi
callq 0x9100
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x90d0
testb $0x1, %al
jne 0x8f73
jmp 0x9063
movl -0x14(%rbp), %edi
callq 0x3450
movq -0x98(%rbp), %rdi
movq %rax, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
callq 0x33a0
cmpq $0x0, -0x30(%rbp)
je 0x8fbe
movq -0x98(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0x3390
jmp 0x8fab
jmp 0x8fbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x9055
movq -0x98(%rbp), %rdx
movq -0x88(%rbp), %rax
addq $0xc8, %rax
movq %rax, -0xa0(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x9170
jmp 0x8fe8
movq -0xa0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x9130
movb %dl, -0xa9(%rbp)
movq %rax, -0xa8(%rbp)
jmp 0x9007
movb -0xa9(%rbp), %al
movq -0xa8(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movb %al, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x91b0
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x9053
jmp 0x9047
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x91b0
jmp 0x9055
movq -0x98(%rbp), %rdi
callq 0x31c0
jmp 0x907f
movq -0x98(%rbp), %rdi
callq 0x31c0
jmp 0x908f
leaq -0x20(%rbp), %rdi
callq 0x91d0
movq -0x98(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x3140
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3480
nopl (%rax,%rax)
// File: j-faria[P]kima/examples/arbitrary_units/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    datafile = "HD128621_rhk.rdb";

    load(datafile, "arb", 2);

    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(50);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x6f0, %rsp            # imm = 0x6F0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xad498(%rip), %rdi     # 0x11a7b8
movq %rdi, -0x6f0(%rbp)
leaq 0x58683(%rip), %rsi     # 0xc59b1
callq 0x6690
movq -0x6f0(%rbp), %rdi
movl $0x2, -0x14(%rbp)
leaq 0x5867a(%rip), %rsi     # 0xc59c2
leaq -0x14(%rbp), %rdx
callq 0x6da60
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x6d0(%rbp), %rdi
movq %rdi, -0x6e8(%rbp)
callq 0x6dba0
movq -0x6e8(%rbp), %rdi
movl $0x32, %esi
callq 0x6dc40
jmp 0x6d37e
movl $0x0, -0x4(%rbp)
leaq -0x6d0(%rbp), %rdi
callq 0x6e060
movl -0x4(%rbp), %eax
addq $0x6f0, %rsp            # imm = 0x6F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x6d8(%rbp)
movl %eax, -0x6dc(%rbp)
leaq -0x6d0(%rbp), %rdi
callq 0x6e060
movq -0x6d8(%rbp), %rdi
callq 0x6830
nopw (%rax,%rax)
// File: kylegranger[P]ImageScaling/filter16.cpp
// Function: DownfilterX(color_t*, color_t*)
void DownfilterX(color_t *src, color_t *dst)
{
	// we mix four source pixels into one destination pixel
	// All on same scanline.
	dst->r = ((src[0].r + 3 * (src[1].r + src[2].r) + src[3].r + 4) >> 3);
	dst->g = ((src[0].g + 3 * (src[1].g + src[2].g) + src[3].g + 4) >> 3);
	dst->b = ((src[0].b + 3 * (src[1].b + src[2].b) + src[3].b + 4) >> 3);
	dst->a = ((src[0].a + 3 * (src[1].a + src[2].a) + src[3].a + 4) >> 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0xc(%rcx), %ecx
movq -0x8(%rbp), %rdx
movzwl 0x14(%rdx), %edx
addl %edx, %ecx
imull $0x3, %ecx, %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movzwl 0x1c(%rcx), %ecx
addl %ecx, %eax
addl $0x4, %eax
sarl $0x3, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0xa(%rcx), %ecx
movq -0x8(%rbp), %rdx
movzwl 0x12(%rdx), %edx
addl %edx, %ecx
imull $0x3, %ecx, %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movzwl 0x1a(%rcx), %ecx
addl %ecx, %eax
addl $0x4, %eax
sarl $0x3, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x8(%rcx), %ecx
movq -0x8(%rbp), %rdx
movzwl 0x10(%rdx), %edx
addl %edx, %ecx
imull $0x3, %ecx, %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
addl %ecx, %eax
addl $0x4, %eax
sarl $0x3, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movq -0x8(%rbp), %rax
movzwl 0x6(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0xe(%rcx), %ecx
movq -0x8(%rbp), %rdx
movzwl 0x16(%rdx), %edx
addl %edx, %ecx
imull $0x3, %ecx, %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movzwl 0x1e(%rcx), %ecx
addl %ecx, %eax
addl $0x4, %eax
sarl $0x3, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x6(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kylegranger[P]ImageScaling/filter16.cpp
// Function: DownfilterXLeft(color_t*, color_t*)
void DownfilterXLeft(color_t *src, color_t *dst)
{
	// we mix three source pixels into one destination pixel
	// All on same scanline.
	dst->r = ((3 * (src[1].r + src[2].r) + src[3].r + 3) / 7);
	dst->g = ((3 * (src[1].g + src[2].g) + src[3].g + 3) / 7);
	dst->b = ((3 * (src[1].b + src[2].b) + src[3].b + 3) / 7);
	dst->a = ((3 * (src[1].a + src[2].a) + src[3].a + 3) / 7);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x14(%rcx), %ecx
addl %ecx, %eax
imull $0x3, %eax, %eax
movq -0x8(%rbp), %rcx
movzwl 0x1c(%rcx), %ecx
addl %ecx, %eax
addl $0x3, %eax
movl $0x7, %ecx
cltd
idivl %ecx
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x8(%rbp), %rax
movzwl 0xa(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x12(%rcx), %ecx
addl %ecx, %eax
imull $0x3, %eax, %eax
movq -0x8(%rbp), %rcx
movzwl 0x1a(%rcx), %ecx
addl %ecx, %eax
addl $0x3, %eax
movl $0x7, %ecx
cltd
idivl %ecx
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x10(%rcx), %ecx
addl %ecx, %eax
imull $0x3, %eax, %eax
movq -0x8(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
addl %ecx, %eax
addl $0x3, %eax
movl $0x7, %ecx
cltd
idivl %ecx
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movq -0x8(%rbp), %rax
movzwl 0xe(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x16(%rcx), %ecx
addl %ecx, %eax
imull $0x3, %eax, %eax
movq -0x8(%rbp), %rcx
movzwl 0x1e(%rcx), %ecx
addl %ecx, %eax
addl $0x3, %eax
movl $0x7, %ecx
cltd
idivl %ecx
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x6(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kylegranger[P]ImageScaling/filter16.cpp
// Function: DownfilterXRight(color_t*, color_t*)
void DownfilterXRight(color_t *src, color_t *dst)
{
	// we mix three source pixels into one destination pixel
	// All on same scanline.
	dst->r = ((src[0].r + 3 * (src[1].r + src[2].r) + 3) / 7);
	dst->g = ((src[0].g + 3 * (src[1].g + src[2].g) + 3) / 7);
	dst->b = ((src[0].b + 3 * (src[1].b + src[2].b) + 3) / 7);
	dst->a = ((src[0].a + 3 * (src[1].a + src[2].a) + 3) / 7);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0xc(%rcx), %ecx
movq -0x8(%rbp), %rdx
movzwl 0x14(%rdx), %edx
addl %edx, %ecx
imull $0x3, %ecx, %ecx
addl %ecx, %eax
addl $0x3, %eax
movl $0x7, %ecx
cltd
idivl %ecx
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0xa(%rcx), %ecx
movq -0x8(%rbp), %rdx
movzwl 0x12(%rdx), %edx
addl %edx, %ecx
imull $0x3, %ecx, %ecx
addl %ecx, %eax
addl $0x3, %eax
movl $0x7, %ecx
cltd
idivl %ecx
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x8(%rcx), %ecx
movq -0x8(%rbp), %rdx
movzwl 0x10(%rdx), %edx
addl %edx, %ecx
imull $0x3, %ecx, %ecx
addl %ecx, %eax
addl $0x3, %eax
movl $0x7, %ecx
cltd
idivl %ecx
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movq -0x8(%rbp), %rax
movzwl 0x6(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0xe(%rcx), %ecx
movq -0x8(%rbp), %rdx
movzwl 0x16(%rdx), %edx
addl %edx, %ecx
imull $0x3, %ecx, %ecx
addl %ecx, %eax
addl $0x3, %eax
movl $0x7, %ecx
cltd
idivl %ecx
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x6(%rax)
popq %rbp
retq