LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: parse(std::vector<Token, std::allocator<Token>>*, std::vector<char*, std::allocator<char*>>*)
vector<AbstractStatementNode*>* parse(vector<Token>* tokenRef, vector<char*>* sourceCodeLines) {

  codeLines = sourceCodeLines;

  //set static variables to correct initial values
  tokenIndex = 0;
  tokens = tokenRef;
  symbolTable = new SymbolTable();
	returnFlag = vector<bool*>();
	returnValue = vector<ParseData*>();
	returnType = vector<ParseDataType>();
	insideClassDefinition = false;
  
  //create empty statement vector
  vector<AbstractStatementNode*>* statements = new vector<AbstractStatementNode*>();
  
  //append statement nodes until END is reached
  while(peek()->type != END) {
    statements->push_back(addStatement());
  }
  
  return statements;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x1a5ea(%rip)     # 0x54408
movl $0x0, 0x1a5d8(%rip)     # 0x54400
movq -0x8(%rbp), %rax
movq %rax, 0x1a5c5(%rip)     # 0x543f8
movl $0x10, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
callq 0x2bc60
jmp 0x39e4e
movq -0x80(%rbp), %rax
movq %rax, 0x1a5b7(%rip)     # 0x54410
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4160
leaq -0x38(%rbp), %rdi
callq 0x39f90
leaq 0x1a537(%rip), %rdi     # 0x543b0
leaq -0x38(%rbp), %rsi
callq 0x3aa90
leaq -0x38(%rbp), %rdi
callq 0x39fb0
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4160
leaq -0x50(%rbp), %rdi
callq 0x3a010
leaq 0x1a51d(%rip), %rdi     # 0x543c8
leaq -0x50(%rbp), %rsi
callq 0x3aac0
leaq -0x50(%rbp), %rdi
callq 0x3a030
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4160
leaq -0x68(%rbp), %rdi
callq 0x3a090
leaq 0x1a503(%rip), %rdi     # 0x543e0
leaq -0x68(%rbp), %rsi
callq 0x3aaf0
leaq -0x68(%rbp), %rdi
callq 0x3a0b0
movb $0x0, 0x1a522(%rip)     # 0x54418
movl $0x18, %edi
callq 0x4260
movq %rax, %rdi
movq %rdi, -0x88(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x4160
movq -0x88(%rbp), %rdi
callq 0x3a340
movq -0x88(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x2fe60
cmpl $0x4e, (%rax)
je 0x39f74
movq -0x70(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x312e0
movq -0x90(%rbp), %rdi
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x3a360
jmp 0x39f2d
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x4240
jmp 0x39f81
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4420
nopw (%rax,%rax)
// File: vividvilla[P]hackerrank/src/median.cpp
// Function: main
int main() {
    int n;
    long long x;
    char o;
    cin >> n;

    vector<char> ops;
    vector<long long> ints;
    for (int i = 0; i < n; i++) {
        cin >> o >> x;
        ops.push_back(o);
        ints.push_back(x);
    }

    outputMedians(ops, ints);

    return 0;
}

// Assembly:
subq $0x98, %rsp
movl $0x0, 0x94(%rsp)
movq 0x64f7(%rip), %rdi      # 0x7fe0
leaq 0x90(%rsp), %rsi
callq 0x10e0
leaq 0x68(%rsp), %rdi
callq 0x1ec0
leaq 0x50(%rsp), %rdi
callq 0x1ed0
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x90(%rsp), %eax
jge 0x1b96
movq 0x64ba(%rip), %rdi      # 0x7fe0
leaq 0x87(%rsp), %rsi
callq 0x1180
movq %rax, (%rsp)
jmp 0x1b39
movq (%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x1170
jmp 0x1b4c
leaq 0x68(%rsp), %rdi
leaq 0x87(%rsp), %rsi
callq 0x1ee0
jmp 0x1b60
leaq 0x50(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x1f50
jmp 0x1b74
jmp 0x1b76
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x1b12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x1c3d
leaq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x1fc0
jmp 0x1ba7
leaq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x20c0
jmp 0x1bb8
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1320
jmp 0x1bc9
leaq 0x8(%rsp), %rdi
callq 0x21c0
leaq 0x20(%rsp), %rdi
callq 0x2220
movl $0x0, 0x94(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x21c0
leaq 0x68(%rsp), %rdi
callq 0x2220
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x1c33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x21c0
leaq 0x20(%rsp), %rdi
callq 0x2220
leaq 0x50(%rsp), %rdi
callq 0x21c0
leaq 0x68(%rsp), %rdi
callq 0x2220
movq 0x40(%rsp), %rdi
callq 0x11d0
nopl (%rax,%rax)
// File: vividvilla[P]hackerrank/src/insertionsort2.cpp
// Function: outputSteps(std::vector<int, std::allocator<int>>)
void outputSteps(vector<int> ar) {
    int M = ar.size();

    for (int N = 2; N <= M; N++) {
        int el = ar[N - 1];
        for (int i = N - 1; i >= 0; i--) {
            if (i > 0 && ar[i - 1] > el)
                ar[i] = ar[i - 1];
            else
                ar[i] = el;

            if (ar[i] <= el)
                break;
        }

        for (int j = 0; j < M; j++) {
            cout << ar[j];
            if (j + 1 < M)
                cout << " ";
            else
                cout << endl;
        }
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
callq 0x14d0
movl %eax, 0x2c(%rsp)
movl $0x2, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jg 0x13de
movq 0x10(%rsp), %rdi
movl 0x28(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x14f0
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x28(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x20(%rsp)
cmpl $0x0, 0x20(%rsp)
jl 0x1359
cmpl $0x0, 0x20(%rsp)
jle 0x1311
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x14f0
movl (%rax), %eax
cmpl 0x24(%rsp), %eax
jle 0x1311
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x14f0
movq 0x10(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movslq 0x20(%rsp), %rsi
callq 0x14f0
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
jmp 0x132e
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x8(%rsp)
movslq 0x20(%rsp), %rsi
callq 0x14f0
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x14f0
movl (%rax), %eax
cmpl 0x24(%rsp), %eax
jg 0x1347
jmp 0x1359
jmp 0x1349
movl 0x20(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x12b2
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x13cc
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x14f0
movl (%rax), %esi
movq 0x3c4d(%rip), %rdi      # 0x4fd0
callq 0x1100
movl 0x1c(%rsp), %eax
addl $0x1, %eax
cmpl 0x2c(%rsp), %eax
jge 0x13aa
movq 0x3c34(%rip), %rdi      # 0x4fd0
leaq 0x1c61(%rip), %rsi      # 0x3004
callq 0x10a0
jmp 0x13bd
movq 0x3c1f(%rip), %rdi      # 0x4fd0
movq 0x3c08(%rip), %rsi      # 0x4fc0
callq 0x10d0
jmp 0x13bf
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1361
jmp 0x13ce
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x127f
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: vividvilla[P]hackerrank/src/insertionsort2.cpp
// Function: main
int main() {
    int s, x;
    cin >> s;

    vector<int> ar;
    for (int i = 0; i < s; i++) {
        cin >> x;
        ar.push_back(x);
    }

    outputSteps(ar);
}

// Assembly:
subq $0x58, %rsp
movl $0x0, 0x54(%rsp)
movq 0x3bdd(%rip), %rdi      # 0x4fe0
leaq 0x50(%rsp), %rsi
callq 0x1070
leaq 0x30(%rsp), %rdi
callq 0x1510
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x50(%rsp), %eax
jge 0x146c
movq 0x3bb0(%rip), %rdi      # 0x4fe0
leaq 0x4c(%rsp), %rsi
callq 0x1070
jmp 0x143c
leaq 0x30(%rsp), %rdi
leaq 0x4c(%rsp), %rsi
callq 0x1520
jmp 0x144d
jmp 0x144f
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x141f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x14b6
movq %rsp, %rdi
leaq 0x30(%rsp), %rsi
callq 0x1590
jmp 0x147b
movq %rsp, %rdi
callq 0x1260
jmp 0x1485
movq %rsp, %rdi
callq 0x1690
leaq 0x30(%rsp), %rdi
callq 0x1690
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movq %rsp, %rdi
callq 0x1690
leaq 0x30(%rsp), %rdi
callq 0x1690
movq 0x20(%rsp), %rdi
callq 0x1110
nopw (%rax,%rax)
// File: jmbjorndalen[P]Malbolge-gen/mbolge-gen.cpp
// Function: MBSearch::storeMem(unsigned short, unsigned short)
unsigned short MBSearch::storeMem(unsigned short addr, unsigned short val)
{
    // NB: writes to an addr always occurs after a read to the same addr, so we never have to consider path branching 
    // or any other recording here. 
    if (addr >= MAX_TRIT)
    { 
	std::cerr << "MBSearch::storeMem called with addr " << addr << " with is outside legal bounds\n";
	throw ILLEGAL_ADDR_EXCEPTION; // program made an illegal reference, which will not fare well with the original interpreter, so abort this branch
    }
    if (addr >= maxAllowedProgLen) 
	throw MAX_APLEN_EXCEPTION;

    mem[addr] = val;
    return 0; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzwl -0xa(%rbp), %eax
cmpl $0xe6a9, %eax           # imm = 0xE6A9
jl 0x404aae
movq $0x5f9420, %rdi         # imm = 0x5F9420
leaq 0x181813(%rip), %rsi    # 0x58627e
callq 0x4737e0
movq %rax, %rdi
movzwl -0xa(%rbp), %esi
callq 0x473e00
movq %rax, %rdi
leaq 0x18181d(%rip), %rsi    # 0x5862a3
callq 0x4737e0
movl $0x4, %edi
callq 0x4096b0
movq %rax, %rdi
movl $0x2b, (%rdi)
leaq 0x1e9f0b(%rip), %rsi    # 0x5ee9b0
xorl %eax, %eax
movl %eax, %edx
callq 0x40a700
movzwl -0xa(%rbp), %eax
cmpl 0x1f1678(%rip), %eax    # 0x5f6130
jl 0x404add
movl $0x4, %edi
callq 0x4096b0
movq %rax, %rdi
movl $0x2c, (%rdi)
leaq 0x1e9edc(%rip), %rsi    # 0x5ee9b0
xorl %eax, %eax
movl %eax, %edx
callq 0x40a700
movq -0x18(%rbp), %rdi
movzwl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
addq $0x18, %rdi
movzwl -0xa(%rbp), %eax
movl %eax, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x405d00
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jmbjorndalen[P]Malbolge-gen/mbolge-gen.cpp
// Function: op(unsigned short, unsigned short)
static inline unsigned short op(unsigned short x, unsigned short y)
{
    unsigned short i = 0, j;
    static const unsigned short p9[5] =
	{ 1, 9, 81, 729, 6561 };  // Tritvals :  1=3**0, 9=3**2, 81=3**4, 729=3**6, 6561=3**8
    static const unsigned short o[9][9] =
	{
	    { 4, 3, 3, 1, 0, 0, 1, 0, 0 },
	    { 4, 3, 5, 1, 0, 2, 1, 0, 2 },
	    { 5, 5, 4, 2, 2, 1, 2, 2, 1 },
	    { 4, 3, 3, 1, 0, 0, 7, 6, 6 },
	    { 4, 3, 5, 1, 0, 2, 7, 6, 8 },
	    { 5, 5, 4, 2, 2, 1, 8, 8, 7 },
	    { 7, 6, 6, 7, 6, 6, 4, 3, 3 },
	    { 7, 6, 8, 7, 6, 8, 4, 3, 5 },
	    { 8, 8, 7, 8, 8, 7, 5, 5, 4 },
	};
    for (j = 0; j < 5; j++)
	i += o [y / p9[j] % 9] [x / p9[j] % 9] * p9[j];
    return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movw $0x0, -0x6(%rbp)
movw $0x0, -0x8(%rbp)
movzwl -0x8(%rbp), %eax
cmpl $0x5, %eax
jge 0x40507a
movzwl -0x4(%rbp), %eax
movzwl -0x8(%rbp), %ecx
movl %ecx, %edx
leaq 0x1811c4(%rip), %rcx    # 0x5861c0
movzwl (%rcx,%rdx,2), %ecx
cltd
idivl %ecx
movl $0x9, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x1811bb(%rip), %rax    # 0x5861d0
imulq $0x12, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
movzwl -0x8(%rbp), %ecx
movl %ecx, %edx
leaq 0x18118f(%rip), %rcx    # 0x5861c0
movzwl (%rcx,%rdx,2), %ecx
cltd
idivl %ecx
movl $0x9, %ecx
cltd
idivl %ecx
movq -0x10(%rbp), %rax
movslq %edx, %rcx
movzwl (%rax,%rcx,2), %ecx
movzwl -0x8(%rbp), %eax
movl %eax, %edx
leaq 0x181168(%rip), %rax    # 0x5861c0
movzwl (%rax,%rdx,2), %eax
imull %eax, %ecx
movzwl -0x6(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x6(%rbp)
movw -0x8(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x8(%rbp)
jmp 0x404fde
movw -0x6(%rbp), %ax
popq %rbp
retq
// File: jmbjorndalen[P]Malbolge-gen/mbolge-gen.cpp
// Function: MBSearch::initExec()
void MBSearch::initExec()
{
    Ra = 0;
    Rc = 0; 
    Rd = 0; 
    output = ""; 
    odepth = 0; 
    iStage = STAGE_IFETCH; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movw $0x0, (%rdi)
movw $0x0, 0x2(%rdi)
movw $0x0, 0x4(%rdi)
addq $0x88, %rdi
leaq 0x19f57f(%rip), %rsi    # 0x5a4652
callq 0x484730
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movl $0x0, 0x7c(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: jmbjorndalen[P]Malbolge-gen/mbolge-gen.cpp
// Function: MBSearch::dumpProgram(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void MBSearch::dumpProgram(std::string fname)
{
    std::ofstream f(fname.c_str(), std::ios::trunc); 

    for (int i = 0; i <= highestAddrRead; i++) 
    {
	MBMemory::iterator pos = mem.find(i); 
	if (pos == mem.end())
	    f << (char) (encode_op(OP_NOP, i));   // Since these aren't fetched, I could dump anything here
	else
	    f << (char) orig[i]; 
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rsi, -0x258(%rbp)
movq %rdi, %rax
movq -0x258(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x250(%rbp)
callq 0x485120
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
movl $0x20, %edx
callq 0x4501e0
movl $0x0, -0x214(%rbp)
movq -0x250(%rbp), %rcx
movl -0x214(%rbp), %eax
cmpl 0x78(%rcx), %eax
jg 0x405275
movq -0x250(%rbp), %rdi
addq $0x18, %rdi
movl -0x214(%rbp), %eax
movl %eax, -0x224(%rbp)
leaq -0x224(%rbp), %rsi
callq 0x405c50
movq %rax, -0x260(%rbp)
jmp 0x405184
movq -0x250(%rbp), %rdi
movq -0x260(%rbp), %rax
movq %rax, -0x220(%rbp)
addq $0x18, %rdi
callq 0x405cb0
movq %rax, -0x240(%rbp)
leaq -0x220(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x405ee0
testb $0x1, %al
jne 0x4051c2
jmp 0x405219
movzwl -0x214(%rbp), %esi
movl $0x23, %edi
callq 0x4049f0
movw %ax, -0x262(%rbp)
jmp 0x4051dc
movw -0x262(%rbp), %cx
movw %cx, %ax
movsbl %al, %esi
leaq -0x210(%rbp), %rdi
callq 0x473710
jmp 0x4051f7
jmp 0x40525f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x450890
jmp 0x40528a
movq -0x250(%rbp), %rdi
addq $0x48, %rdi
movl -0x214(%rbp), %eax
movl %eax, -0x244(%rbp)
leaq -0x244(%rbp), %rsi
callq 0x405d00
movq %rax, -0x270(%rbp)
jmp 0x405245
movq -0x270(%rbp), %rax
movsbl (%rax), %esi
leaq -0x210(%rbp), %rdi
callq 0x473710
jmp 0x40525d
jmp 0x40525f
jmp 0x405261
movl -0x214(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x214(%rbp)
jmp 0x405142
leaq -0x210(%rbp), %rdi
callq 0x450890
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x230(%rbp), %rdi
callq 0x4b4f90
nopw %cs:(%rax,%rax)
// File: jmbjorndalen[P]Malbolge-gen/mbolge-gen.cpp
// Function: printCurOutput(MBSearch*, int)
void printCurOutput(MBSearch *cur, int newline = true)
{
    std::cout << "\r   output from program '" << cur->output << "' "
	      << "maxMemLoc " << cur->maxMemLoc() 
	      << " nFetches " << cur->nFetches << "                     "; 
    if (newline)
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x5f9540, %rdi         # imm = 0x5F9540
leaq 0x181038(%rip), %rsi    # 0x5862f5
callq 0x4737e0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x88, %rsi
callq 0x486110
movq %rax, %rdi
leaq 0x181030(%rip), %rsi    # 0x58630f
callq 0x4737e0
movq %rax, %rdi
leaq 0x181024(%rip), %rsi    # 0x586312
callq 0x4737e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x405f10
movq -0x18(%rbp), %rdi
movl %eax, %esi
callq 0x473b80
movq %rax, %rdi
leaq 0x181008(%rip), %rsi    # 0x58631d
callq 0x4737e0
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x473b80
movq %rax, %rdi
leaq 0x180ff5(%rip), %rsi    # 0x586328
callq 0x4737e0
cmpl $0x0, -0xc(%rbp)
je 0x405351
movq $0x5f9540, %rdi         # imm = 0x5F9540
movq $0x4730c0, %rsi         # imm = 0x4730C0
callq 0x4722d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jmbjorndalen[P]Malbolge-gen/./utils.h
// Function: imod(int, int)
static inline int imod(int a, int b)
{
    int r = a % b; 
    if (r < 0) 
	return b + r; // (nb: adding negative number)
    else
	return r; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x405b15
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x405b1b
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/main.cc
// Function: usage(char const*)
static int usage(const char *progname) {
    fprintf(stderr, "usage: %s [options]\n", progname);
    fprintf(stderr, "Options:\n"
            "\t-u <udp-size>        : Maximum UDP to PixelPusher. Default %d.\n"
            "\t-b <brightness%%>     : Percent brightness. Default: 100\n"
            "\t-d                   : Become daemon\n"
            "\t--layer-timeout <sec>: Layer timeout: clearing after non-activity (Default: 15)\n", kDefaultPacketSize);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x9845(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x58f1(%rip), %rsi      # 0x8092
movb $0x0, %al
callq 0x22a0
movq 0x9829(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
leaq 0x58ee(%rip), %rsi      # 0x80a7
movl $0x5b4, %edx            # imm = 0x5B4
movb $0x0, %al
callq 0x22a0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/ft-thread.cc
// Function: ft::Thread::WaitStopped()
void Thread::WaitStopped() {
    if (!started_) return;
    int result = pthread_join(thread_, NULL);
    if (result != 0) {
        fprintf(stderr, "err code: %d %s\n", result, strerror(result));
    }
    started_ = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x8(%rax)
jne 0x289c
jmp 0x28f2
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x21c0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x28ea
movq 0x971b(%rip), %rax      # 0xbfd8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %edi
callq 0x20b0
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq %rax, %rcx
leaq 0x58bf(%rip), %rsi      # 0x81a2
movb $0x0, %al
callq 0x22a0
movq -0x18(%rbp), %rax
movb $0x0, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/ft-thread.cc
// Function: ft::Thread::Start(int, unsigned int)
void Thread::Start(int priority, uint32_t affinity_mask) {
    assert(!started_);  // Did you call WaitStopped() ?
    pthread_create(&thread_, NULL, &PthreadCallRun, this);

    if (priority > 0) {
        struct sched_param p;
        p.sched_priority = priority;
        pthread_setschedparam(thread_, SCHED_FIFO, &p);
    }

#ifndef __APPLE__
    if (affinity_mask != 0) {
        cpu_set_t cpu_mask;
        CPU_ZERO(&cpu_mask);
        for (int i = 0; i < 32; ++i) {
            if ((affinity_mask & (1<<i)) != 0) {
                CPU_SET(i, &cpu_mask);
            }
        }
        pthread_setaffinity_np(thread_, sizeof(cpu_mask), &cpu_mask);
    }
#endif

    started_ = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movb 0x8(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x293b
jmp 0x293d
jmp 0x295c
leaq 0x586f(%rip), %rdi      # 0x81b3
leaq 0x5872(%rip), %rsi      # 0x81bd
movl $0x31, %edx
leaq 0x5873(%rip), %rcx      # 0x81ca
callq 0x2150
movq -0xb8(%rbp), %rcx
movq %rcx, %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x165(%rip), %rdx      # 0x2810
callq 0x2360
cmpl $0x0, -0xc(%rbp)
jle 0x299f
movq -0xb8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, -0x14(%rbp)
movq 0x10(%rax), %rdi
movl $0x1, %esi
leaq -0x14(%rbp), %rdx
callq 0x2160
cmpl $0x0, -0x10(%rbp)
je 0x2a91
jmp 0x29ab
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x2110
movl $0x0, -0x9c(%rbp)
cmpl $0x20, -0x9c(%rbp)
jge 0x2a75
movl -0x10(%rbp), %eax
movl -0x9c(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2a5f
movslq -0x9c(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
shrq $0x3, %rax
cmpq $0x80, %rax
jae 0x2a46
movq -0xa8(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq -0xa8(%rbp), %rcx
shrq $0x6, %rcx
orq -0x98(%rbp,%rcx,8), %rax
movq %rax, -0x98(%rbp,%rcx,8)
movq %rax, -0xc0(%rbp)
jmp 0x2a51
xorl %eax, %eax
movq %rax, -0xc0(%rbp)
jmp 0x2a51
movq -0xc0(%rbp), %rax
movq %rax, -0xb0(%rbp)
jmp 0x2a61
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x29c8
movq -0xb8(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x80, %esi
leaq -0x98(%rbp), %rdx
callq 0x2320
movq -0xb8(%rbp), %rax
movb $0x1, 0x8(%rax)
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/ft-thread.cc
// Function: ft::Mutex::WaitOnWithTimeout(pthread_cond_t*, int)
bool Mutex::WaitOnWithTimeout(pthread_cond_t *cond, int wait_ms) {
    if (wait_ms <= 0) return 1;  // already expired.
    struct timespec abs_time;
#ifndef __APPLE__
    clock_gettime(CLOCK_REALTIME, &abs_time);
#else
    struct timeval apple_time;
    gettimeofday(&apple_time, NULL);
    abs_time.tv_sec = apple_time.tv_sec;
    abs_time.tv_nsec = apple_time.tv_usec * 1000;
#endif
    abs_time.tv_sec += wait_ms / 1000;
    abs_time.tv_nsec += 1000000 * (wait_ms % 1000);
    if (abs_time.tv_nsec > 1000000000) {
        abs_time.tv_sec += 1;
        abs_time.tv_nsec -= 1000000000;
    }
    return pthread_cond_timedwait(cond, &mutex_, &abs_time) == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x2ad7
movb $0x1, -0x1(%rbp)
jmp 0x2b52
xorl %edi, %edi
leaq -0x30(%rbp), %rsi
callq 0x21d0
movl -0x1c(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cltq
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
imull $0xf4240, %edx, %eax    # imm = 0xF4240
cltq
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x3b9aca00, -0x28(%rbp) # imm = 0x3B9ACA00
jle 0x2b36
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
subq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x22d0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/ft-server.cc
// Function: udp_server_init(int)
bool udp_server_init(int port) {
    if ((server_socket = socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
        perror("IPv6 enabled ? While reating listen socket");
        return false;
    }
    int opt = 0;   // Unset IPv6-only, in case it is set. Best effort.
    setsockopt(server_socket, IPPROTO_IPV6, IPV6_V6ONLY, &opt, sizeof(opt));

    struct sockaddr_in6 addr = {0};
    addr.sin6_family = AF_INET6;
    addr.sin6_addr = in6addr_any;
    addr.sin6_port = htons(port);
    if (bind(server_socket, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
        perror("bind");
        return false;
    }

    fprintf(stderr, "FlaschenTaschen server: ready to listen on %d\n", port);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl $0xa, %edi
movl $0x2, %esi
movl $0x11, %edx
callq 0x2090
movl %eax, 0x96a3(%rip)      # 0xc238
cmpl $0x0, %eax
jge 0x2baf
leaq 0x5664(%rip), %rdi      # 0x8205
callq 0x21b0
movb $0x0, -0x1(%rbp)
jmp 0x2c5a
movl $0x0, -0xc(%rbp)
movl 0x967c(%rip), %edi      # 0xc238
movl $0x29, %esi
movl $0x1a, %edx
leaq -0xc(%rbp), %rcx
movl $0x4, %r8d
callq 0x2340
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x1c, %edx
callq 0x2110
movw $0xa, -0x28(%rbp)
movq 0x93ee(%rip), %rax      # 0xbfe0
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movzwl %ax, %edi
callq 0x2060
movw %ax, -0x26(%rbp)
movl 0x9622(%rip), %edi      # 0xc238
leaq -0x28(%rbp), %rsi
movl $0x1c, %edx
callq 0x2080
cmpl $0x0, %eax
jge 0x2c3b
leaq 0x5600(%rip), %rdi      # 0x8230
callq 0x21b0
movb $0x0, -0x1(%rbp)
jmp 0x2c5a
movq 0x9396(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0x55e6(%rip), %rsi      # 0x8235
movb $0x0, %al
callq 0x22a0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::~CompositeFlaschenTaschen()
CompositeFlaschenTaschen::~CompositeFlaschenTaschen() {
    if (garbage_collect_) {
        garbage_collect_->TriggerExit();
        garbage_collect_->WaitStopped();
    }
    for (size_t i = 0; i < screens_.size(); ++i) delete screens_[i];
    delete z_buffer_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x8a45(%rip), %rcx      # 0xbc10
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x60(%rax)
je 0x31f9
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x3b10
jmp 0x31e8
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x2880
jmp 0x31f7
jmp 0x31f9
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x28, %rdi
callq 0x3b60
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x3267
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x3b80
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x3257
movq -0x28(%rbp), %rdi
callq 0x3ba0
movq -0x28(%rbp), %rdi
movl $0x10, %esi
callq 0x21f0
jmp 0x3259
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3201
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3290
movq -0x30(%rbp), %rdi
callq 0x3bc0
movq -0x30(%rbp), %rdi
movl $0x10, %esi
callq 0x21f0
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
callq 0x3a50
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x3ab0
movq -0x18(%rbp), %rdi
callq 0x3d50
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x2b60
nopw %cs:(%rax,%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::SetPixelAtLayer(int, int, int, Color const&)
void CompositeFlaschenTaschen::SetPixelAtLayer(int x, int y, int layer,
                                               const Color &col) {
    screens_[layer]->At(x, y) = col;
    if (layer >= z_buffer_->At(x, y)) {
        any_visible_pixel_drawn_ = true;
        if (col.is_black()) {
            // Transparent pixel. Find closest stacked below us that is not.
            for (/**/; layer > 0; --layer) {
                if (!screens_[layer]->At(x, y).is_black())
                    break;
            }
            delegatee_->SetPixel(x, y, screens_[layer]->At(x, y));
        } else {
            delegatee_->SetPixel(x, y, col);
        }
        z_buffer_->At(x, y) = layer;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x28, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3b80
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x3500
movq -0x38(%rbp), %rdx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movw (%rdx), %si
movw %si, (%rcx)
movb 0x2(%rdx), %dl
movb %dl, 0x2(%rcx)
movl -0x14(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq 0x40(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x3530
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl (%rcx), %eax
jl 0x34b8
movq -0x30(%rbp), %rax
movb $0x1, 0x1c(%rax)
movq -0x20(%rbp), %rdi
callq 0x3be0
testb $0x1, %al
jne 0x33f8
jmp 0x3482
jmp 0x33fa
cmpl $0x0, -0x14(%rbp)
jle 0x343a
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3b80
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x3500
movq %rax, %rdi
callq 0x3be0
testb $0x1, %al
jne 0x342d
jmp 0x343a
jmp 0x342f
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x33fa
movq -0x30(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x3c(%rbp)
addq $0x28, %rdi
movslq -0x14(%rbp), %rsi
callq 0x3b80
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x3500
movq -0x48(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x3c(%rbp), %edx
movq %rax, %rcx
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x349a
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x20(%rbp), %rcx
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x4c(%rbp)
movq 0x40(%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x3530
movl -0x4c(%rbp), %ecx
movl %ecx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::Send()
void CompositeFlaschenTaschen::Send() {
    // Don't send anything if we only had pixels in hidden layers.
    if (any_visible_pixel_drawn_)
        delegatee_->Send();
    any_visible_pixel_drawn_ = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x1c(%rax)
je 0x34e8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::SetLayer(int)
void CompositeFlaschenTaschen::SetLayer(int layer) {
    if (layer < 0) layer = 0;
    if (layer >= (int)screens_.size()) layer = screens_.size() - 1;
    current_layer_ = layer;
    last_layer_update_time_[current_layer_] = current_time_;
}

// 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)
cmpl $0x0, -0xc(%rbp)
jge 0x3584
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
addq $0x28, %rdi
callq 0x3b60
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jl 0x35b5
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x3b60
subq $0x1, %rax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl 0x20(%rax), %ecx
movl %ecx, -0x20(%rbp)
movq %rax, %rdi
addq $0x48, %rdi
movslq 0x18(%rax), %rsi
callq 0x3c30
movl -0x20(%rbp), %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::StartLayerGarbageCollection(ft::Mutex*, int)
void CompositeFlaschenTaschen::StartLayerGarbageCollection(ft::Mutex *lock,
                                                           int timeout_seconds) {
    assert(garbage_collect_ == NULL);  // only start once.
    assert(lock != NULL);  // Must provide mutex.
    garbage_collect_ = new LayerGarbageCollector(this, lock, timeout_seconds);
    garbage_collect_->Start();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x60(%rax)
jne 0x3604
jmp 0x3623
leaq 0x4ce6(%rip), %rdi      # 0x82f1
leaq 0x4c76(%rip), %rsi      # 0x8288
movl $0x9e, %edx
leaq 0x4cec(%rip), %rcx      # 0x830a
callq 0x2150
cmpq $0x0, -0x10(%rbp)
je 0x362c
jmp 0x364b
leaq 0x4d24(%rip), %rdi      # 0x8357
leaq 0x4c4e(%rip), %rsi      # 0x8288
movl $0x9f, %edx
leaq 0x4cc4(%rip), %rcx      # 0x830a
callq 0x2150
movl $0x68, %edi
callq 0x21e0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x3c50
jmp 0x3671
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq 0x60(%rax), %rdi
movq (%rdi), %rax
xorl %edx, %edx
movl %edx, %esi
callq *0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x68, %esi
callq 0x21f0
movq -0x20(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::ClearLayersOlderThan(int)
void CompositeFlaschenTaschen::ClearLayersOlderThan(Ticks cutoff_time) {
    const Color black(0, 0, 0);
    bool any_change = false;
    // Only cleaning layers above zero (= background)
    for (size_t layer = 1; layer < last_layer_update_time_.size(); ++layer) {
        if (last_layer_update_time_[layer] > cutoff_time)
            continue;
        // Not very efficient, but good for now:
        for (int x = 0; x < width_; ++x) {
            for (int y = 0; y < height_; ++y) {
                SetPixelAtLayer(x, y, layer, black);
            }
        }
        last_layer_update_time_[layer] = INT_MAX;
        any_change = true;
    }
    if (any_change) Send();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0xf(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x3cc0
movb $0x0, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x48, %rdi
callq 0x3cf0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x37b4
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
movq -0x18(%rbp), %rsi
callq 0x3c30
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x3731
jmp 0x37a3
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x3788
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x377b
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rax
movl %eax, %ecx
leaq -0xf(%rbp), %r8
callq 0x3360
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x374b
jmp 0x377d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3738
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
movq -0x18(%rbp), %rsi
callq 0x3c30
movl $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
movb $0x1, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x36f2
testb $0x1, -0x10(%rbp)
je 0x37c4
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::LayerGarbageCollector::Run()
void Run() {
        for (;;) {
            ft::MutexLock m(lock_);
            lock_->WaitOnWithTimeout(&running_cond_, 1000);
            if (!running_) break;
            owner_->ClearLayersOlderThan(ticks_ - max_age_);
            owner_->SetTimeTicks(ticks_);
            ++ticks_;  // one tick, roughly one second.
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rsi
leaq -0x10(%rbp), %rdi
callq 0x3ed0
movq -0x28(%rbp), %rsi
movq 0x20(%rsi), %rdi
addq $0x30, %rsi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x2ab0
jmp 0x3fbd
movq -0x28(%rbp), %rax
testb $0x1, 0x60(%rax)
jne 0x3fe7
movl $0x2, -0x20(%rbp)
jmp 0x4024
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3f00
jmp 0x4043
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
movl 0x64(%rax), %esi
movl 0x28(%rax), %eax
subl %eax, %esi
callq 0x36c0
jmp 0x3ffe
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
movl 0x64(%rax), %esi
callq 0x4050
jmp 0x4010
movq -0x28(%rbp), %rax
movl 0x64(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x64(%rax)
movl $0x0, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3f00
movl -0x20(%rbp), %eax
testl %eax, %eax
je 0x4038
jmp 0x4036
jmp 0x403d
jmp 0x3f94
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2330
nopl (%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/ppm-reader.cc
// Function: readNextNumber(char const**, char const*, ImageMetaInfo*)
static int readNextNumber(const char **start, const char *end,
                          struct ImageMetaInfo *info) {
    const char *start_number = skipWhitespace(*start, end, info);
    if (start_number == NULL) { *start = NULL; return 0; }
    char *end_number = NULL;
    int result = strtol(start_number, &end_number, 10);
    if (end_number == start_number) { *start = NULL; return 0; }
    *start = end_number;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5670
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5597
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x55e3
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0xa, %edx
callq 0x2280
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x55d2
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x55e3
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/ppm-reader.cc
// Function: parseOffsets(char const*, char const*, ImageMetaInfo*)
static void parseOffsets(const char *start, const char *end,
                         struct ImageMetaInfo *info) {
    info->offset_x = readNextNumber(&start, end, NULL);
    if (start != NULL) {
        info->offset_y = readNextNumber(&start, end, NULL);
    }
    if (start != NULL) {
        info->layer = readNextNumber(&start, end, NULL);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x5550
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
cmpq $0x0, -0x8(%rbp)
je 0x563f
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x5550
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
cmpq $0x0, -0x8(%rbp)
je 0x5660
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x5550
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/ppm-reader.cc
// Function: skipWhitespace(char const*, char const*, ImageMetaInfo*)
static const char *skipWhitespace(const char *buffer, const char *end,
                                  struct ImageMetaInfo *info) {
    for (;;) {
        while (buffer < end && isspace(*buffer))
            ++buffer;
        if (buffer >= end)
            return NULL;
        if (*buffer == '#') {
            const char *start = buffer;
            while (buffer < end && *buffer != '\n') // read to end of line.
                ++buffer;
            parseSpecialComment(start, buffer, info);
            continue;  // Back to whitespace eating.
        }
        return buffer;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0x5686
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x29(%rbp)
jae 0x56aa
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2070
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x56b3
jmp 0x56c1
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5686
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x56d5
movq $0x0, -0x8(%rbp)
jmp 0x573d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x5735
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x2a(%rbp)
jae 0x5708
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x5711
jmp 0x571f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x56e9
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5750
jmp 0x5684
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/ppm-reader.cc
// Function: parseSpecialComment(char const*, char const*, ImageMetaInfo*)
static void parseSpecialComment(const char *start, const char *end,
                                struct ImageMetaInfo *info) {
    if (info == NULL) return;
    if (end - start < 4) return;
    if (strncmp(start, "#FT:", 4) != 0) return;
    parseOffsets(start + 4, end, info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x576d
jmp 0x57b1
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
cmpq $0x4, %rax
jge 0x5780
jmp 0x57b1
movq -0x8(%rbp), %rdi
leaq 0x2c54(%rip), %rsi      # 0x83df
movl $0x4, %edx
callq 0x20e0
cmpl $0x0, %eax
je 0x579c
jmp 0x57b1
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x55f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/pixel-pusher-client.cc
// Function: OpenPPSocket(char const*, char const*)
static int OpenPPSocket(const char *host, const char *port) {
    struct addrinfo addr_hints = {0};
    addr_hints.ai_family = AF_INET;
    addr_hints.ai_socktype = SOCK_DGRAM;

    struct addrinfo *addr_result = NULL;
    int rc;
    if ((rc = getaddrinfo(host, port, &addr_hints, &addr_result)) != 0) {
        fprintf(stderr, "Resolving '%s': %s\n", host, gai_strerror(rc));
        return -1;
    }
    if (addr_result == NULL)
        return -1;
    int fd = socket(addr_result->ai_family,
                    addr_result->ai_socktype,
                    addr_result->ai_protocol);
    if (fd >= 0 &&
        connect(fd, addr_result->ai_addr, addr_result->ai_addrlen) < 0) {
        perror("connect()");
        close(fd);
        fd = -1;
    }

    freeaddrinfo(addr_result);
    return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2110
movl $0x2, -0x44(%rbp)
movl $0x2, -0x40(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x2240
movl %eax, -0x54(%rbp)
cmpl $0x0, %eax
je 0x5a63
movq 0x65ae(%rip), %rax      # 0xbfd8
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x54(%rbp), %edi
callq 0x2270
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rdx
movq %rax, %rcx
leaq 0x2a5d(%rip), %rsi      # 0x84b0
movb $0x0, %al
callq 0x22a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5adc
cmpq $0x0, -0x50(%rbp)
jne 0x5a73
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5adc
movq -0x50(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x50(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x50(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x2090
movl %eax, -0x58(%rbp)
cmpl $0x0, -0x58(%rbp)
jl 0x5acd
movl -0x58(%rbp), %edi
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x50(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x21a0
cmpl $0x0, %eax
jge 0x5acd
leaq 0x2a0b(%rip), %rdi      # 0x84c4
callq 0x21b0
movl -0x58(%rbp), %edi
callq 0x2370
movl $0xffffffff, -0x58(%rbp) # imm = 0xFFFFFFFF
movq -0x50(%rbp), %rdi
callq 0x2260
movl -0x58(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/pixel-pusher-client.cc
// Function: PixelPusherClient::SetPixel(int, int, Color const&)
void PixelPusherClient::SetPixel(int x, int y, const Color &col) {
    if (x < 0 || x >= width_ || y < 0 || y >= height_) return;
    Color *row = (Color*) (pixel_buffer_ + y*row_size_ + 1);
    Color new_color = CIEMapColor(brightness_percent_, col);
    const int packet = y / rows_per_packet_;
    block_dirty_[packet] |= (row[x].r != new_color.r ||
                             row[x].g != new_color.g ||
                             row[x].b != new_color.b);
    row[x] = new_color;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x5c12
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x5c12
cmpl $0x0, -0x10(%rbp)
jl 0x5c12
movq -0x30(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jl 0x5c17
jmp 0x5d02
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rsi
movq 0x38(%rax), %rcx
movslq -0x10(%rbp), %rdx
imulq %rsi, %rdx
leaq 0x1(%rcx,%rdx), %rcx
movq %rcx, -0x20(%rbp)
movzbl 0x28(%rax), %edi
movq -0x18(%rbp), %rsi
callq 0x5d10
movq -0x30(%rbp), %rcx
movw %ax, %dx
movw %dx, -0x23(%rbp)
shrl $0x10, %eax
movb %al, -0x21(%rbp)
movl -0x10(%rbp), %eax
cltd
idivl 0x20(%rcx)
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl (%rax), %ecx
movzbl -0x23(%rbp), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x31(%rbp)
jne 0x5cba
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl 0x1(%rax), %ecx
movzbl -0x22(%rbp), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x31(%rbp)
jne 0x5cba
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movzbl 0x2(%rax), %eax
movzbl -0x21(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x31(%rbp)
movq -0x30(%rbp), %rax
movb -0x31(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %esi
movq 0x30(%rax), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
andb $0x1, %dl
movzbl %dl, %edx
orl %esi, %edx
cmpl $0x0, %edx
setne %dl
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movw -0x23(%rbp), %cx
movw %cx, (%rax)
movb -0x21(%rbp), %cl
movb %cl, 0x2(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hzeller[P]FlaschenTaschen-PixelPusher-bridge/pixel-pusher-client.cc
// Function: CIEMapColor(unsigned char, Color const&)
static inline Color CIEMapColor(uint8_t brightness, const Color& col) {
    static ColorLookup *luminance_lookup = CreateLuminanceCIE1931LookupTable();
    return Color(luminance_lookup[brightness - 1].color[col.r],
                 luminance_lookup[brightness - 1].color[col.g],
                 luminance_lookup[brightness - 1].color[col.b]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
movb %al, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpb $0x0, 0x6547(%rip)      # 0xc270
jne 0x5d5e
leaq 0x653e(%rip), %rdi      # 0xc270
callq 0x2350
cmpl $0x0, %eax
je 0x5d5e
callq 0x5f50
movq %rax, -0x28(%rbp)
jmp 0x5d47
movq -0x28(%rbp), %rax
movq %rax, 0x6516(%rip)      # 0xc268
leaq 0x6517(%rip), %rdi      # 0xc270
callq 0x2140
movq 0x6503(%rip), %rcx      # 0xc268
movzbl -0x4(%rbp), %eax
shll $0x9, %eax
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %edx
movzwl -0x200(%rax,%rdx,2), %esi
movzbl 0x1(%rcx), %edx
movzwl -0x200(%rax,%rdx,2), %edx
movzbl 0x2(%rcx), %ecx
movzwl -0x200(%rax,%rcx,2), %ecx
leaq -0x3(%rbp), %rdi
callq 0x3cc0
movb -0x1(%rbp), %al
movb %al, -0x1e(%rbp)
movw -0x3(%rbp), %ax
movw %ax, -0x20(%rbp)
movzbl -0x1e(%rbp), %ecx
shll $0x10, %ecx
movzwl -0x20(%rbp), %eax
orl %ecx, %eax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq 0x649d(%rip), %rdi      # 0xc270
callq 0x2130
movq -0x18(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)