LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: shangjingbo1226[P]MACFP/src/methods/../utils/helper.h
// Function: tryOpen(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
FILE* tryOpen(string filename, string param)
{
	FILE* ret = fopen(filename.c_str(), param.c_str());
	if (ret == NULL) {
		fprintf(stderr, "error while opening %s\n", filename.c_str());
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x30e0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x30e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x3300
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3d2d
movq -0x30(%rbp), %rdi
movq 0x252c4(%rip), %rax     # 0x28fd0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x30e0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x182fd(%rip), %rsi     # 0x1c023
movb $0x0, %al
callq 0x3370
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: shangjingbo1226[P]MACFP/src/methods/../utils/helper.h
// Function: splitBy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector<string> splitBy(const string &line, char comma)
{
	vector<string> tokens;
	string token = "";
	bool inside = false;
	for (size_t i = 0; i < line.size(); ++ i) {
		if (line[i] == '"') {
			inside ^= 1;
		} else if (line[i] == comma && !inside) {
			tokens.push_back(token);
			token = "";
		} else {
			token += line[i];
		}
	}
	tokens.push_back(token);
	return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x82e0
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3430
movq -0x60(%rbp), %rdx
leaq 0x18411(%rip), %rsi     # 0x1c195
leaq -0x38(%rbp), %rdi
callq 0x8300
jmp 0x3d8f
leaq -0x39(%rbp), %rdi
callq 0x32c0
movb $0x0, -0x4d(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x3e99
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x32e0
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x3e0f
movb -0x4d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
xorl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x4d(%rbp)
jmp 0x3e86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x32c0
jmp 0x3ed1
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x32e0
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3e67
testb $0x1, -0x4d(%rbp)
jne 0x3e67
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x83b0
jmp 0x3e3c
leaq 0x18352(%rip), %rsi     # 0x1c195
leaq -0x38(%rbp), %rdi
callq 0x3350
jmp 0x3e4e
jmp 0x3e84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34a8
jmp 0x3ed1
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x32e0
movsbl (%rax), %esi
leaq -0x38(%rbp), %rdi
callq 0x3160
jmp 0x3e82
jmp 0x3e84
jmp 0x3e86
jmp 0x3e88
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x3da4
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x83b0
jmp 0x3ea8
movb $0x1, -0x12(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34a8
testb $0x1, -0x12(%rbp)
jne 0x3ec4
movq -0x70(%rbp), %rdi
callq 0x8420
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x8420
movq -0x48(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: shangjingbo1226[P]MACFP/src/methods/MACFP.cpp
// Function: checkSmallPatch(int, int)
vector<PII> checkSmallPatch(int l, int r)
{
    int length = r - l + 1;
    //myAssert(length <= SMALL_PATCH, "only for small patch!");
    vector<PII> ret(1, make_pair(l, r));
    enumerateEdit(l, 0, l, r, 1, s->size(), EDIT_DIS_THRES, ret);
    return makeMaximal(ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
subl %ecx, %eax
incl %eax
movl %eax, -0x14(%rbp)
leaq -0xc(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x8fe0
movq %rax, -0x38(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x9030
movq -0x58(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
leaq -0x38(%rbp), %rdx
callq 0x9050
jmp 0x71b3
leaq -0x39(%rbp), %rdi
callq 0x90d0
movl -0xc(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl %eax, -0x78(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x74(%rbp)
movq 0x5f80236(%rip), %rdi   # 0x5f87408
callq 0x8620
movq %rax, -0x70(%rbp)
jmp 0x71dd
movl -0x74(%rbp), %ecx
movl -0x7c(%rbp), %edx
movl -0x78(%rbp), %edi
movq -0x70(%rbp), %rax
movl %eax, %r9d
movl 0x22075(%rip), %esi     # 0x29268
movq %rsp, %rax
leaq -0x30(%rbp), %r8
movq %r8, 0x8(%rax)
movl %esi, (%rax)
xorl %esi, %esi
movl $0x1, %r8d
callq 0x6890
jmp 0x720f
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x38e0
jmp 0x721e
leaq -0x30(%rbp), %rdi
callq 0x8170
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x90d0
jmp 0x7260
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8170
movq -0x48(%rbp), %rdi
callq 0x3420
nopl (%rax)
// File: shangjingbo1226[P]MACFP/src/methods/../utils/suffix_array.h
// Function: SuffixArray::lcp(long long, long long)
long long lcp(long long i, long long j) {
        long long ret = 0;
        if (i == j) {
            ret = n - 1 - i;
        } else {
            long long l = rank[i], r = rank[j];
            if (l > r) {
                swap(l, r);
            }
            l += 1;
            ret = getMin(0, n - 1, l, r);
        }
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x8aa3
movq -0x38(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
subq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8b1c
movq -0x38(%rbp), %rdi
addq $0xa0, %rdi
movq -0x10(%rbp), %rsi
callq 0x8570
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
addq $0xa0, %rdi
movq -0x18(%rbp), %rsi
callq 0x8570
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x8af0
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xadb0
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq (%rdi), %rdx
subq $0x1, %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
xorl %eax, %eax
movl %eax, %esi
callq 0xadf0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: shangjingbo1226[P]MACFP/src/methods/../utils/suffix_array.h
// Function: SuffixArray::getMin(long long, long long, long long, long long)
long long getMin(long long l, long long r, long long ll, long long rr) {
        if (r < ll || l > rr) {
            return INF_LL;
        }
        if (ll <= l && r <= rr) {
            return segment_tree[ID(l, r)];
        }
        long long mid = l + r >> 1;
        return min(getMin(l, mid, ll, rr), getMin(mid + 1, r, ll, rr));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jl 0xae28
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0xae3b
movabsq $0xde0b6b3a7640000, %rax # imm = 0xDE0B6B3A7640000
movq %rax, -0x8(%rbp)
jmp 0xaee4
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jg 0xae83
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jg 0xae83
movq -0x50(%rbp), %rdi
addq $0xd0, %rdi
movq -0x18(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
orq %rax, %rsi
callq 0x8570
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xaee4
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
sarq %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xadf0
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rsi
addq $0x1, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xadf0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xaef0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: shangjingbo1226[P]MACFP/src/methods/../utils/suffix_array.h
// Function: SuffixArray::build_tree(long long, long long)
void build_tree(long long l, long long r) {
        if (l == r) {
            segment_tree[ID(l, r)] = height[l];
            return;
        }
        long long mid = l + r >> 1;
        build_tree(l, mid);
        build_tree(mid + 1, r);
        segment_tree[ID(l, r)] = min(segment_tree[ID(l, mid)], segment_tree[ID(mid + 1, r)]);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xead8
movq -0x28(%rbp), %rdi
addq $0xb8, %rdi
movq -0x10(%rbp), %rsi
callq 0x8570
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x30(%rbp)
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
addq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
orq %rax, %rsi
callq 0x8570
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xebb4
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
sarq %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xea60
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
movq -0x18(%rbp), %rdx
callq 0xea60
movq -0x28(%rbp), %rdi
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
orq %rax, %rsi
callq 0x8570
movq -0x28(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0xd0, %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
addq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
addq $0x1, %rax
cmpq -0x18(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
orq %rax, %rsi
callq 0x8570
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xaef0
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
addq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
orq %rax, %rsi
callq 0x8570
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: shangjingbo1226[P]MACFP/src/methods/../utils/suffix_array.h
// Function: SuffixArray::sort(int*, int*, int*, long long, int)
void sort(int *r, int *a, int *b, long long n, int m) {
        for (long long i = 0; i < n; ++ i) {
            wv[i] = r[a[i]];
        }
        for (int i = 0; i < m; ++ i) {
            wss[i]=0;
        }
        for (long long i = 0; i < n; ++ i) {
            ++ wss[wv[i]];
        }
        for (int i = 1; i < m; ++ i) {
            wss[i] += wss[i - 1];
        }
        for (long long i = n - 1; i >= 0; -- i) {
            b[-- wss[wv[i]]] = a[i];
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x104e7
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x64(%rbp)
addq $0x70, %rdi
movq -0x38(%rbp), %rsi
callq 0x8590
movl -0x64(%rbp), %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x104a3
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x1051b
movq -0x60(%rbp), %rdi
addq $0x88, %rdi
movslq -0x3c(%rbp), %rsi
callq 0x8590
movl $0x0, (%rax)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x104ee
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x1056c
movq -0x60(%rbp), %rdi
movq %rdi, %rax
addq $0x88, %rax
movq %rax, -0x70(%rbp)
addq $0x70, %rdi
movq -0x48(%rbp), %rsi
callq 0x8590
movq -0x70(%rbp), %rdi
movslq (%rax), %rsi
callq 0x8590
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x10523
movl $0x1, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x105bf
movq -0x60(%rbp), %rdi
addq $0x88, %rdi
movl -0x4c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x8590
movq -0x60(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x74(%rbp)
addq $0x88, %rdi
movslq -0x4c(%rbp), %rsi
callq 0x8590
movl -0x74(%rbp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x10573
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jl 0x10643
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x58(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x84(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq %rdi, %rax
addq $0x88, %rax
movq %rax, -0x90(%rbp)
addq $0x70, %rdi
movq -0x58(%rbp), %rsi
callq 0x8590
movq -0x90(%rbp), %rdi
movslq (%rax), %rsi
callq 0x8590
movl -0x84(%rbp), %edx
movq %rax, %rsi
movq -0x80(%rbp), %rax
movl (%rsi), %ecx
addl $-0x1, %ecx
movl %ecx, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x58(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x105cb
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: shangjingbo1226[P]MACFP/src/methods/../utils/suffix_array.h
// Function: SuffixArray::c12(int, int*, long long, long long)
int c12(int k, int *r, long long a, long long b) {
        if (k == 2) {
            return r[a] < r[b] || r[a] == r[b] && c12(1, r, a + 1, b + 1);
        } else {
            return r[a] < r[b] || r[a] == r[b] && wv[a + 1] < wv[b + 1];
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0x10774
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rsi
movb $0x1, %al
cmpl (%rdx,%rsi,4), %ecx
movb %al, -0x39(%rbp)
jl 0x10764
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rsi
xorl %eax, %eax
cmpl (%rdx,%rsi,4), %ecx
movb %al, -0x3a(%rbp)
jne 0x1075e
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
movq -0x30(%rbp), %r8
addq $0x1, %r8
movl $0x1, %esi
callq 0x106d0
cmpl $0x0, %eax
setne %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x107fc
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rsi
movb $0x1, %al
cmpl (%rdx,%rsi,4), %ecx
movb %al, -0x3b(%rbp)
jl 0x107f1
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rsi
xorl %eax, %eax
cmpl (%rdx,%rsi,4), %ecx
movb %al, -0x3c(%rbp)
jne 0x107eb
movq -0x38(%rbp), %rdi
addq $0x70, %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
callq 0x8590
movq -0x38(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x40(%rbp)
addq $0x70, %rdi
movq -0x30(%rbp), %rsi
addq $0x1, %rsi
callq 0x8590
movq %rax, %rcx
movl -0x40(%rbp), %eax
cmpl (%rcx), %eax
setl %al
movb %al, -0x3c(%rbp)
movb -0x3c(%rbp), %al
movb %al, -0x3b(%rbp)
movb -0x3b(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: akshithasriraman[P]Accelerometer/run.cc
// Function: ExecuteShellCommand[abi:cxx11](char const*)
std::string ExecuteShellCommand(const char* cmd)
{
    char buffer[128];
    std::string result = "";
    std::shared_ptr<FILE> pipe(popen(cmd, "r"), pclose);
    if (!pipe) throw std::runtime_error("popen() failed!");
    while (!feof(pipe.get())) {
        if (fgets(buffer, 128, pipe.get()) != NULL)
            result += buffer;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x91(%rbp)
leaq -0x92(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x2250
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rdx
leaq 0x2175(%rip), %rsi      # 0x4588
callq 0x2a40
jmp 0x241a
leaq -0x92(%rbp), %rdi
callq 0x2190
movq -0x10(%rbp), %rdi
leaq 0x1bd3(%rip), %rsi      # 0x4004
callq 0x2050
movq %rax, -0xd8(%rbp)
jmp 0x243f
movq -0xd8(%rbp), %rsi
movq 0x4b83(%rip), %rdx      # 0x6fd0
leaq -0xb8(%rbp), %rdi
callq 0x2af0
jmp 0x245b
leaq -0xb8(%rbp), %rdi
callq 0x2b20
testb $0x1, %al
jne 0x2527
movl $0x10, %edi
callq 0x20a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
leaq 0x1b79(%rip), %rsi      # 0x4006
callq 0x2070
jmp 0x2494
movq -0xe0(%rbp), %rdi
movq 0x4b4e(%rip), %rsi      # 0x6ff0
movq 0x4b0f(%rip), %rdx      # 0x6fb8
callq 0x2230
jmp 0x25fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x92(%rbp), %rdi
callq 0x2190
jmp 0x25ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x25e2
movq -0xe0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
callq 0x20e0
jmp 0x25b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x25b8
jmp 0x2529
leaq -0xb8(%rbp), %rdi
callq 0x2b40
movq %rax, %rdi
callq 0x2200
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x254b
jmp 0x259a
leaq -0xb8(%rbp), %rdi
callq 0x2b40
movq %rax, %rdx
leaq -0x90(%rbp), %rdi
movl $0x80, %esi
callq 0x2210
movq %rax, -0xe8(%rbp)
jmp 0x2574
movq -0xe8(%rbp), %rax
cmpq $0x0, %rax
je 0x2598
movq -0xc8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2140
jmp 0x2596
jmp 0x2598
jmp 0x2529
movb $0x1, -0x91(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x2b60
testb $0x1, -0x91(%rbp)
jne 0x25d2
jmp 0x25c6
leaq -0xb8(%rbp), %rdi
callq 0x2b60
jmp 0x25e2
movq -0xc8(%rbp), %rdi
callq 0x20b0
movq -0xd0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x20b0
movq -0xa0(%rbp), %rdi
callq 0x2240
nopw (%rax,%rax)
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: add_message(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void add_message(std::string msg)
{
	//if(msg.length() > viewport_width) return 1;
	rlmessages.push_back(msg);
	std::string word_so_far = "";
	for(unsigned int i=0; i<msg.length();i++)
	{
		if(msg[i] == ' ' || msg[i] == '\t' || msg[i] == '\n')
		{
			rlmessage_words.push_back(word_so_far);
			word_so_far = "";
		}
		else
		{
			word_so_far = word_so_far + msg[i];
		}
	}
	rlmessage_words.push_back(word_so_far);
	//return 0;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, %rsi
movq %rsi, 0x28(%rsp)
movq %rsi, 0x90(%rsp)
leaq 0x81c1a(%rip), %rdi     # 0x882a8
callq 0x1fd40
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x5490
movq 0x30(%rsp), %rdx
leaq 0x279b3(%rip), %rsi     # 0x2e061
leaq 0x70(%rsp), %rdi
callq 0x53d0
jmp 0x66ba
leaq 0x6f(%rsp), %rdi
callq 0x5310
movl $0x0, 0x58(%rsp)
movq 0x28(%rsp), %rdi
movl 0x58(%rsp), %eax
movq %rax, 0x20(%rsp)
callq 0x5410
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x6814
movq 0x28(%rsp), %rdi
movl 0x58(%rsp), %eax
movl %eax, %esi
callq 0x54e0
movq %rax, 0x18(%rsp)
jmp 0x6707
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x675c
movq 0x28(%rsp), %rdi
movl 0x58(%rsp), %eax
movl %eax, %esi
callq 0x54e0
movq %rax, 0x10(%rsp)
jmp 0x672b
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
je 0x675c
movq 0x28(%rsp), %rdi
movl 0x58(%rsp), %eax
movl %eax, %esi
callq 0x54e0
movq %rax, 0x8(%rsp)
jmp 0x674f
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x67bb
leaq 0x81b5d(%rip), %rdi     # 0x882c0
leaq 0x70(%rsp), %rsi
callq 0x1fd40
jmp 0x676f
leaq 0x278eb(%rip), %rsi     # 0x2e061
leaq 0x70(%rsp), %rdi
callq 0x53c0
jmp 0x6782
jmp 0x6802
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x6f(%rsp), %rdi
callq 0x5310
jmp 0x6839
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x54f8
jmp 0x6839
movq 0x28(%rsp), %rdi
movl 0x58(%rsp), %eax
movl %eax, %esi
callq 0x54e0
movq %rax, (%rsp)
jmp 0x67d1
movq (%rsp), %rax
movsbl (%rax), %edx
leaq 0x38(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x1fdb0
jmp 0x67e9
leaq 0x70(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5370
leaq 0x38(%rsp), %rdi
callq 0x54f8
jmp 0x6804
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x66cc
leaq 0x81aa5(%rip), %rdi     # 0x882c0
leaq 0x70(%rsp), %rsi
callq 0x1fd40
jmp 0x6827
leaq 0x70(%rsp), %rdi
callq 0x54f8
addq $0x98, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x5480
nopw %cs:(%rax,%rax)
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: random_start_cluster[abi:cxx11]()
std::string random_start_cluster()
{
	switch (rand()%10)
	{
	case 0: case 1: case 2: case 3:
		return clusters_1[rand()%vclusters_1.size()];
	case 4: case 5: case 6:
		return start_clusters_2[rand()%vstart_clusters_2.size()];
	default:
		return start_clusters_3[rand()%vstart_clusters_3.size()];
	}
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x50(%rsp)
movq %rdi, %rax
movq %rax, 0x58(%rsp)
movq %rdi, 0x80(%rsp)
callq 0x50b0
movslq %eax, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rcx
shrq $0x3f, %rcx
sarq $0x22, %rdx
addl %ecx, %edx
addl %edx, %edx
movl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movl %eax, 0x64(%rsp)
subl $0x4, %eax
jb 0x8d71
jmp 0x8d5c
movl 0x64(%rsp), %eax
addl $-0x4, %eax
subl $0x3, %eax
jb 0x8df7
jmp 0x8e7d
callq 0x50b0
cltq
movq %rax, 0x38(%rsp)
leaq 0x7f71c(%rip), %rdi     # 0x884a0
callq 0x1fe40
movq %rax, %rcx
movq 0x38(%rsp), %rax
xorl %edx, %edx
divq %rcx
leaq 0x31613(%rip), %rax     # 0x3a3b0
movq (%rax,%rdx,8), %rax
movq %rax, 0x40(%rsp)
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x5490
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x53d0
jmp 0x8dcb
leaq 0x7f(%rsp), %rdi
callq 0x5310
jmp 0x8efd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x7f(%rsp), %rdi
callq 0x5310
jmp 0x8f0a
callq 0x50b0
cltq
movq %rax, 0x20(%rsp)
leaq 0x7f6ae(%rip), %rdi     # 0x884b8
callq 0x1fe40
movq %rax, %rcx
movq 0x20(%rsp), %rax
xorl %edx, %edx
divq %rcx
leaq 0x3162d(%rip), %rax     # 0x3a450
movq (%rax,%rdx,8), %rax
movq %rax, 0x28(%rsp)
leaq 0x6b(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x5490
movq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x53d0
jmp 0x8e51
leaq 0x6b(%rsp), %rdi
callq 0x5310
jmp 0x8efd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x6b(%rsp), %rdi
callq 0x5310
jmp 0x8f0a
callq 0x50b0
cltq
movq %rax, 0x8(%rsp)
leaq 0x7f640(%rip), %rdi     # 0x884d0
callq 0x1fe40
movq %rax, %rcx
movq 0x8(%rsp), %rax
xorl %edx, %edx
divq %rcx
leaq 0x31a87(%rip), %rax     # 0x3a930
movq (%rax,%rdx,8), %rax
movq %rax, 0x10(%rsp)
leaq 0x6a(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5490
movq 0x50(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x53d0
jmp 0x8ed7
leaq 0x6a(%rsp), %rdi
callq 0x5310
jmp 0x8efd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x6a(%rsp), %rdi
callq 0x5310
jmp 0x8f0a
movq 0x58(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x5480
nopw %cs:(%rax,%rax)
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: random_vowel[abi:cxx11]()
std::string random_vowel()
{
	switch (rand()%5)
	{
	case 0: case 1: case 2:
		return pure_vowels[rand()%vpure_vowels.size()];
	default:
		return diphthongs[rand()%vdiphthongs.size()];
	}
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x60(%rsp)
callq 0x50b0
movslq %eax, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rcx
shrq $0x3f, %rcx
sarq $0x21, %rdx
addl %ecx, %edx
movl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
subl $0x2, %eax
ja 0x8fea
jmp 0x8f64
callq 0x50b0
cltq
movq %rax, 0x20(%rsp)
leaq 0x7f571(%rip), %rdi     # 0x884e8
callq 0x1fe40
movq %rax, %rcx
movq 0x20(%rsp), %rax
xorl %edx, %edx
divq %rcx
leaq 0x319f0(%rip), %rax     # 0x3a980
movq (%rax,%rdx,8), %rax
movq %rax, 0x28(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x5490
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x53d0
jmp 0x8fbe
leaq 0x5f(%rsp), %rdi
callq 0x5310
jmp 0x906a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x5f(%rsp), %rdi
callq 0x5310
jmp 0x9074
callq 0x50b0
cltq
movq %rax, 0x8(%rsp)
leaq 0x7f503(%rip), %rdi     # 0x88500
callq 0x1fe40
movq %rax, %rcx
movq 0x8(%rsp), %rax
xorl %edx, %edx
divq %rcx
leaq 0x319aa(%rip), %rax     # 0x3a9c0
movq (%rax,%rdx,8), %rax
movq %rax, 0x10(%rsp)
leaq 0x4b(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5490
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x53d0
jmp 0x9044
leaq 0x4b(%rsp), %rdi
callq 0x5310
jmp 0x906a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x4b(%rsp), %rdi
callq 0x5310
jmp 0x9074
movq 0x40(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x5480
nop
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: random_end_cluster[abi:cxx11]()
std::string random_end_cluster()
{
	switch (rand()%7)
	{
	case 0: case 1: case 2: case 3:
		return clusters_1[rand()%vclusters_1.size()];
	default://case 4: case 5: case 6:
		return end_clusters_2[rand()%vend_clusters_2.size()];
	//default:
	//	return start_clusters_3[rand()%start_clusters_3->length()];
	}
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x60(%rsp)
callq 0x50b0
movslq %eax, %rcx
imulq $-0x6db6db6d, %rcx, %rcx # imm = 0x92492493
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x2, %ecx
addl %edx, %ecx
movl %ecx, %edx
shll $0x3, %edx
subl %edx, %ecx
addl %ecx, %eax
subl $0x3, %eax
ja 0x914f
jmp 0x90c9
callq 0x50b0
cltq
movq %rax, 0x20(%rsp)
leaq 0x7f3c4(%rip), %rdi     # 0x884a0
callq 0x1fe40
movq %rax, %rcx
movq 0x20(%rsp), %rax
xorl %edx, %edx
divq %rcx
leaq 0x312bb(%rip), %rax     # 0x3a3b0
movq (%rax,%rdx,8), %rax
movq %rax, 0x28(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x5490
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x53d0
jmp 0x9123
leaq 0x5f(%rsp), %rdi
callq 0x5310
jmp 0x91cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x5f(%rsp), %rdi
callq 0x5310
jmp 0x91d9
callq 0x50b0
cltq
movq %rax, 0x8(%rsp)
leaq 0x7f3b6(%rip), %rdi     # 0x88518
callq 0x1fe40
movq %rax, %rcx
movq 0x8(%rsp), %rax
xorl %edx, %edx
divq %rcx
leaq 0x31925(%rip), %rax     # 0x3aaa0
movq (%rax,%rdx,8), %rax
movq %rax, 0x10(%rsp)
leaq 0x4b(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5490
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x53d0
jmp 0x91a9
leaq 0x4b(%rsp), %rdi
callq 0x5310
jmp 0x91cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x4b(%rsp), %rdi
callq 0x5310
jmp 0x91d9
movq 0x40(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x5480
nopw %cs:(%rax,%rax)
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: init_human_sp()
void init_human_sp()
{
		species* human = new species();
	human->id = 0;
	human->health_range = 0; human->min_health = 100;
	human->ch = '@';
	human->psychic_range=0; human->hearing_thres = 1.0f;
	human->hearing_adapt = 0.5f;
	human->smell_clarity = 0.1f; human->vis_range = 8;
	human->syl1 = "hu"; human->syl2 = "man";
	human->name = "human";
	human->colour = COLOR_WHITE;
	human->damage = 1;
	human->walk_energy = 10;
	human->run_energy = 19;
	human->stamina = 1200;
	human->body_sections = 7;
	human->body_sections_tried = human->body_sections - 1;
	human->crit_part_name = "head";
	human->crit_known = true;
	human->size = 1;
	
	
	human->description = "A legendary advanced alien race whose technology is built specifically for murder, ecological destruction, deception, and gentle shaking. Members of this species must be killed immediately upon discovery to prevent catastrophic damage to the whole area.";
	zoo.push_back(human);
	human_sp = human;
}

// Assembly:
subq $0x18, %rsp
movl $0x150, %edi            # imm = 0x150
callq 0x52c0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x150, %edx            # imm = 0x150
callq 0x51c0
movq 0x8(%rsp), %rdi
callq 0x20440
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0x64, 0x4(%rax)
movq 0x10(%rsp), %rax
movb $0x40, 0x24(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movss 0x23a29(%rip), %xmm0    # 0x2d014
movss %xmm0, 0x18(%rax)
movq 0x10(%rsp), %rax
movss 0x23a13(%rip), %xmm0    # 0x2d010
movss %xmm0, 0x1c(%rax)
movq 0x10(%rsp), %rax
movss 0x239fd(%rip), %xmm0    # 0x2d00c
movss %xmm0, 0x14(%rax)
movq 0x10(%rsp), %rax
movl $0x8, 0x10(%rax)
movq 0x10(%rsp), %rdi
addq $0xb0, %rdi
leaq 0x2434a(%rip), %rsi     # 0x2d97d
callq 0x53c0
movq 0x10(%rsp), %rdi
addq $0xd0, %rdi
leaq 0x24337(%rip), %rsi     # 0x2d982
callq 0x53c0
movq 0x10(%rsp), %rdi
addq $0xf0, %rdi
leaq 0x2431d(%rip), %rsi     # 0x2d980
callq 0x53c0
movq 0x10(%rsp), %rax
movl $0x7, 0x28(%rax)
movq 0x10(%rsp), %rax
movl $0x1, 0xc(%rax)
movq 0x10(%rsp), %rax
movl $0xa, 0x2c(%rax)
movq 0x10(%rsp), %rax
movl $0x13, 0x30(%rax)
movq 0x10(%rsp), %rax
movl $0x4b0, 0x34(%rax)      # imm = 0x4B0
movq 0x10(%rsp), %rax
movl $0x7, 0x3c(%rax)
movq 0x10(%rsp), %rax
movl 0x3c(%rax), %ecx
subl $0x1, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x40(%rax)
movq 0x10(%rsp), %rdi
addq $0x130, %rdi            # imm = 0x130
leaq 0x242b0(%rip), %rsi     # 0x2d986
callq 0x53c0
movq 0x10(%rsp), %rax
movb $0x1, 0x44(%rax)
movq 0x10(%rsp), %rax
movl $0x1, 0x38(%rax)
movq 0x10(%rsp), %rdi
addq $0x110, %rdi            # imm = 0x110
leaq 0x24288(%rip), %rsi     # 0x2d98b
callq 0x53c0
leaq 0x7ed51(%rip), %rdi     # 0x88460
leaq 0x10(%rsp), %rsi
callq 0x204d0
movq 0x10(%rsp), %rax
movq %rax, 0x7ed73(%rip)     # 0x88498
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: terrain_immovable(actor*, int, int)
bool terrain_immovable(actor* a, int x, int y)
{
	if(!on_map(x,y)) return false;
	if (map_terrain[x][y] == WALL || map_terrain[x][y] == NW_SE|| map_terrain[x][y] == SW_NE || map_terrain[x][y] == TWINDOW
		|| map_terrain[x][y] == NS || map_terrain[x][y] == WE || map_terrain[x][y] == NOSE || map_terrain[x][y] == CPANEL) return true;
	if (map_occupants[x][y] != NULL && map_occupants[x][y] != a) return true;
	return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl %edx, (%rsp)
movl 0x4(%rsp), %edi
movl (%rsp), %esi
callq 0x20770
testb $0x1, %al
jne 0xefba
movb $0x0, 0x17(%rsp)
jmp 0xf123
movslq 0x4(%rsp), %rcx
leaq 0x2c3ea(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq (%rsp), %rcx
cmpl $0x4, (%rax,%rcx,4)
je 0xf0ca
movslq 0x4(%rsp), %rcx
leaq 0x2c3c6(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq (%rsp), %rcx
cmpl $0x7, (%rax,%rcx,4)
je 0xf0ca
movslq 0x4(%rsp), %rcx
leaq 0x2c3a2(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq (%rsp), %rcx
cmpl $0x6, (%rax,%rcx,4)
je 0xf0ca
movslq 0x4(%rsp), %rcx
leaq 0x2c37e(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq (%rsp), %rcx
cmpl $0xc, (%rax,%rcx,4)
je 0xf0ca
movslq 0x4(%rsp), %rcx
leaq 0x2c35a(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq (%rsp), %rcx
cmpl $0xa, (%rax,%rcx,4)
je 0xf0ca
movslq 0x4(%rsp), %rcx
leaq 0x2c33a(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq (%rsp), %rcx
cmpl $0xb, (%rax,%rcx,4)
je 0xf0ca
movslq 0x4(%rsp), %rcx
leaq 0x2c31a(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq (%rsp), %rcx
cmpl $0x8, (%rax,%rcx,4)
je 0xf0ca
movslq 0x4(%rsp), %rcx
leaq 0x2c2fa(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq (%rsp), %rcx
cmpl $0x9, (%rax,%rcx,4)
jne 0xf0d1
movb $0x1, 0x17(%rsp)
jmp 0xf123
movslq 0x4(%rsp), %rcx
leaq 0x79483(%rip), %rax     # 0x88560
imulq $0x4b0, %rcx, %rcx      # imm = 0x4B0
addq %rcx, %rax
movslq (%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xf11e
movslq 0x4(%rsp), %rcx
leaq 0x79462(%rip), %rax     # 0x88560
imulq $0x4b0, %rcx, %rcx      # imm = 0x4B0
addq %rcx, %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x8(%rsp), %rax
je 0xf11e
movb $0x1, 0x17(%rsp)
jmp 0xf123
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: random_occupiable_square_away_from_player()
std::pair<int,int> random_occupiable_square_away_from_player()
{
	int target_x = rand()%MAP_SIZE; int target_y = rand()%MAP_SIZE;
	while((map_terrain[target_x][target_y] != DIRT && map_terrain[target_x][target_y] != FLOOR) || d22(target_x,target_y,p_ptr->x,p_ptr->y) <= (vis_range+2)*(vis_range+2))
	{
		target_x = rand()%MAP_SIZE; target_y = rand()%MAP_SIZE;
	}
	return std::make_pair(target_x,target_y);
}

// Assembly:
subq $0x18, %rsp
callq 0x50b0
movl $0x96, %ecx
cltd
idivl %ecx
movl %edx, 0xc(%rsp)
callq 0x50b0
movl $0x96, %ecx
cltd
idivl %ecx
movl %edx, 0x8(%rsp)
movslq 0xc(%rsp), %rcx
leaq 0x2c24e(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq 0x8(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0xf19e
movslq 0xc(%rsp), %rax
leaq 0x2c22d(%rip), %rcx     # 0x3b3b0
imulq $0x258, %rax, %rax      # imm = 0x258
addq %rax, %rcx
movslq 0x8(%rsp), %rdx
movb $0x1, %al
cmpl $0x3, (%rcx,%rdx,4)
movb %al, 0x7(%rsp)
jne 0xf1c9
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movq 0x793a3(%rip), %rax     # 0x88550
movl 0x20(%rax), %edx
movq 0x79399(%rip), %rax     # 0x88550
movl 0x24(%rax), %ecx
callq 0x6610
cmpl $0x64, %eax
setle %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xf1d3
jmp 0xf1fa
callq 0x50b0
movl $0x96, %ecx
cltd
idivl %ecx
movl %edx, 0xc(%rsp)
callq 0x50b0
movl $0x96, %ecx
cltd
idivl %ecx
movl %edx, 0x8(%rsp)
jmp 0xf156
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x207c0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: count_inv_devices(int)
int count_inv_devices(int dev_type)
{
	int ret = 0;
	for(int i=0; i<DEVICE_CONFIGURATIONS;i++)
	{
		ret += dev_inv[dev_type][i].size();
	}
	return ret;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
jge 0xf8f1
movslq 0x14(%rsp), %rsi
leaq 0xd0bf5(%rip), %rdi     # 0xe04b0
callq 0x20ad0
movq %rax, %rdi
movslq 0xc(%rsp), %rsi
callq 0x20af0
movq %rax, %rdi
callq 0x20b10
movq %rax, %rcx
movslq 0x10(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xf8a8
movl 0x10(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: total_inv_devices()
int total_inv_devices()
{
	int ret = 0;
	for(int i=0;i<DEVICE_TYPES;i++)
		ret += count_inv_devices(i);
	return ret;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
movl $0x0, (%rsp)
cmpl $0x6, (%rsp)
jge 0xf931
movl (%rsp), %edi
callq 0xf890
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0xf910
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw (%rax,%rax)
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: nearby_home_for_item(int, int)
std::pair<int,int> nearby_home_for_item(int x,int y)
{
	if(map_items[x][y] == NULL && !(map_terrain[x][y]==WALL))
	{
		return std::make_pair(x,y);
	}
	for(int d=0;d<8;d++)
	{
		std::pair<int,int> dir = directions[d];
		int xx = x+dir.first; int yy =y+dir.second;
		if(map_items[xx][yy] == NULL && !(map_terrain[xx][yy]==WALL))
		{
			return std::make_pair(xx,yy);
		}
	}
	return std::make_pair(-1,-1);

}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x2c(%rsp)
movl %esi, 0x28(%rsp)
movslq 0x2c(%rsp), %rcx
leaq 0xa4bd8(%rip), %rax     # 0xb4530
imulq $0x4b0, %rcx, %rcx      # imm = 0x4B0
addq %rcx, %rax
movslq 0x28(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xf9a8
movslq 0x2c(%rsp), %rcx
leaq 0x2ba36(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq 0x28(%rsp), %rcx
cmpl $0x4, (%rax,%rcx,4)
je 0xf9a8
leaq 0x2c(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x207c0
movq %rax, 0x30(%rsp)
jmp 0xfa77
movl $0x0, 0x24(%rsp)
cmpl $0x8, 0x24(%rsp)
jge 0xfa53
movslq 0x24(%rsp), %rcx
leaq 0x1de39(%rip), %rax     # 0x2d800
movq (%rax,%rcx,8), %rax
movq %rax, 0x1c(%rsp)
movl 0x2c(%rsp), %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x28(%rsp), %eax
addl 0x20(%rsp), %eax
movl %eax, 0x14(%rsp)
movslq 0x18(%rsp), %rcx
leaq 0xa4b3c(%rip), %rax     # 0xb4530
imulq $0x4b0, %rcx, %rcx      # imm = 0x4B0
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xfa41
movslq 0x18(%rsp), %rcx
leaq 0x2b99a(%rip), %rax     # 0x3b3b0
imulq $0x258, %rcx, %rcx      # imm = 0x258
addq %rcx, %rax
movslq 0x14(%rsp), %rcx
cmpl $0x4, (%rax,%rcx,4)
je 0xfa41
leaq 0x18(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x207c0
movq %rax, 0x30(%rsp)
jmp 0xfa77
jmp 0xfa43
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xf9b0
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x20b30
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: item_to_location(item*, int, int)
void item_to_location(item* a, int x, int y)
{
	if(a->player_has)
	{
		inv_remove(a);
		a->player_has = false;
	}
	std::pair<int,int> place_here = nearby_home_for_item(x,y);
	if(place_here != std::make_pair(-1,-1))
	{
		map_items[place_here.first][place_here.second] = a;
		a->x = place_here.first; a->y = place_here.second;
	}
	else
	{
		add_message("Abnormal item placement! Maybe it's in a wall, maybe it just squashed another item.");
		//draw_last_msg();
		map_items[x][y] = a;
		a->x = x; a->y = y;
	}

}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movl %edx, 0x58(%rsp)
movq 0x60(%rsp), %rax
testb $0x1, 0x98(%rax)
je 0xfb05
movq 0x60(%rsp), %rdi
callq 0xfa90
movq 0x60(%rsp), %rax
movb $0x0, 0x98(%rax)
movl 0x5c(%rsp), %edi
movl 0x58(%rsp), %esi
callq 0xf940
movq %rax, 0x50(%rsp)
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x40(%rsp) # imm = 0xFFFFFFFF
leaq 0x44(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x20b30
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x20c00
testb $0x1, %al
jne 0xfb50
jmp 0xfb97
movq 0x60(%rsp), %rdx
movslq 0x50(%rsp), %rcx
leaq 0xa49cf(%rip), %rax     # 0xb4530
imulq $0x4b0, %rcx, %rcx      # imm = 0x4B0
addq %rcx, %rax
movslq 0x54(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x50(%rsp), %ecx
movq 0x60(%rsp), %rax
movl %ecx, 0x90(%rax)
movl 0x54(%rsp), %ecx
movq 0x60(%rsp), %rax
movl %ecx, 0x94(%rax)
jmp 0xfc54
leaq 0x1f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x5490
movq (%rsp), %rdx
leaq 0x1e1f3(%rip), %rsi     # 0x2dda3
leaq 0x20(%rsp), %rdi
callq 0x53d0
jmp 0xfbbc
leaq 0x20(%rsp), %rdi
callq 0x6670
jmp 0xfbc8
leaq 0x20(%rsp), %rdi
callq 0x54f8
leaq 0x1f(%rsp), %rdi
callq 0x5310
movq 0x60(%rsp), %rdx
movslq 0x5c(%rsp), %rcx
leaq 0xa4943(%rip), %rax     # 0xb4530
imulq $0x4b0, %rcx, %rcx      # imm = 0x4B0
addq %rcx, %rax
movslq 0x58(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x5c(%rsp), %ecx
movq 0x60(%rsp), %rax
movl %ecx, 0x90(%rax)
movl 0x58(%rsp), %ecx
movq 0x60(%rsp), %rax
movl %ecx, 0x94(%rax)
jmp 0xfc54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
jmp 0xfc48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x54f8
leaq 0x1f(%rsp), %rdi
callq 0x5310
jmp 0xfc59
addq $0x68, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x5480
nopw %cs:(%rax,%rax)
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: device_to_inventory(item*)
void device_to_inventory(item* a)
{
	if(!a->player_has)
	{
		map_items[a->x][a->y] = NULL;
		a->player_has = true;
		dev_inv[a->device_type][a->configuration].push_back(a);
	}

}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
testb $0x1, 0x98(%rax)
jne 0xfcee
movq (%rsp), %rax
movslq 0x90(%rax), %rcx
leaq 0xa489c(%rip), %rax     # 0xb4530
imulq $0x4b0, %rcx, %rcx      # imm = 0x4B0
addq %rcx, %rax
movq (%rsp), %rcx
movslq 0x94(%rcx), %rcx
movq $0x0, (%rax,%rcx,8)
movq (%rsp), %rax
movb $0x1, 0x98(%rax)
movq (%rsp), %rax
movslq 0x70(%rax), %rsi
leaq 0xd07e5(%rip), %rdi     # 0xe04b0
callq 0x20ad0
movq %rax, %rdi
movq (%rsp), %rax
movslq 0x8c(%rax), %rsi
callq 0x20af0
movq %rax, %rdi
movq %rsp, %rsi
callq 0x20c30
popq %rax
retq
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: add_junk(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, int, int, int)
void add_junk(std::string name, std::string description, char ch, int colour, int x, int y)
{
	item* it = new item();
	it->projection = NULL;
	it->colour = colour;
	it->ch = ch;
	it->device_type = NOT_DEVICE;
	it->name = name;
	it->description = description;
	it->base_description = "";
	it->player_has = false;
	items.push_back(it);
	item_to_location(it,x,y);

}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movb %dl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb %al, 0x37(%rsp)
movl %ecx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movl %r9d, 0x28(%rsp)
movl $0xa0, %edi
callq 0x52c0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0xa0, %edx
callq 0x51c0
movq 0x8(%rsp), %rdi
callq 0x20ca0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rsi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movl 0x30(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movb 0x37(%rsp), %cl
movq 0x20(%rsp), %rax
movb %cl, 0xc(%rax)
movq 0x20(%rsp), %rax
movl $0xffffffff, 0x70(%rax) # imm = 0xFFFFFFFF
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
callq 0x5040
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
callq 0x5040
movq 0x20(%rsp), %rdi
addq $0x50, %rdi
leaq 0x1e2ad(%rip), %rsi     # 0x2e061
callq 0x53c0
movq 0x20(%rsp), %rax
movb $0x0, 0x98(%rax)
leaq 0xd069c(%rip), %rdi     # 0xe0468
leaq 0x20(%rsp), %rsi
callq 0x20c30
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
callq 0xfad0
addq $0x48, %rsp
retq
nopl (%rax)
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: add_actor(species*, bool, int, int, bool)
actor* add_actor(species* sp, bool p, int xx, int yy,bool hologram=false)
{
	actor* a = new actor();
	a->is_hologram = hologram;
	a->sspecies = sp;
	a->is_player = p;
	a->dead = false;
	a->running = false;
	a->stamina = sp->stamina;
	a->energy = 100*(int)(p);

	a->x = xx;
	a->y = yy;
	a->certain = false;
	a->ai_x = xx;
	a->ai_y = yy;
	a->most_noticeable_sound = 0.0f;
	a->runaway_x = -500;
	a->runaway_y = -500;
	actors.push_back(a);
	if(!hologram)
	{
	map_occupants[xx][yy] = a;
	}
	a->health = (sp->health_range? rand()%(sp->health_range):0)+sp->min_health;
	a->sound_threshold = a->sspecies->hearing_thres;
	if(hologram)
	{
		holograms.push_back(a);
	}
	return a;
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %sil
movb %sil, 0x2f(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
andb $0x1, %al
movb %al, 0x23(%rsp)
movl $0x48, %edi
callq 0x52c0
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
movl $0x48, %edx
callq 0x51c0
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0x23(%rsp), %cl
movq 0x18(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x9(%rax)
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movb 0x2f(%rsp), %cl
movq 0x18(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
movq 0x18(%rsp), %rax
movb $0x0, 0x1c(%rax)
movq 0x18(%rsp), %rax
movb $0x0, 0x14(%rax)
movq 0x30(%rsp), %rax
movl 0x34(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x18(%rax)
movb 0x2f(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
imull $0x64, %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0x28(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x20(%rax)
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x24(%rax)
movq 0x18(%rsp), %rax
movb $0x0, 0x1d(%rax)
movl 0x28(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x28(%rax)
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x2c(%rax)
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x40(%rax)
movq 0x18(%rsp), %rax
movl $0xfffffe0c, 0x30(%rax) # imm = 0xFFFFFE0C
movq 0x18(%rsp), %rax
movl $0xfffffe0c, 0x34(%rax) # imm = 0xFFFFFE0C
leaq 0xd054f(%rip), %rdi     # 0xe0450
leaq 0x18(%rsp), %rsi
callq 0x20ce0
testb $0x1, 0x23(%rsp)
jne 0xff36
movq 0x18(%rsp), %rdx
movslq 0x28(%rsp), %rcx
leaq 0x7863d(%rip), %rax     # 0x88560
imulq $0x4b0, %rcx, %rcx      # imm = 0x4B0
addq %rcx, %rax
movslq 0x24(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x30(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0xff55
callq 0x50b0
movq 0x30(%rsp), %rcx
cltd
idivl 0x8(%rcx)
movl %edx, 0xc(%rsp)
jmp 0xff5d
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0xff5d
movl 0xc(%rsp), %ecx
movq 0x30(%rsp), %rax
addl 0x4(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movss 0x18(%rax), %xmm0
movq 0x18(%rsp), %rax
movss %xmm0, 0x3c(%rax)
testb $0x1, 0x23(%rsp)
je 0xffa0
leaq 0xd04ea(%rip), %rdi     # 0xe0480
leaq 0x18(%rsp), %rsi
callq 0x20ce0
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: essarrdee[P]mutantaliens/mutantaliens.cpp
// Function: five_tries_to_make_room(std::pair<int, int>, int, int)
std::pair<int,int> five_tries_to_make_room(std::pair<int,int> xy, int xcentre, int ycentre)
{
	for(int i=0;i<5;i++)
	{
		std::pair<int,int> ret = can_make_room(xy,xcentre, ycentre);
		if(ret != std::make_pair(0,0)) return ret;
	}
	return std::make_pair(0,0);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
cmpl $0x5, 0x2c(%rsp)
jge 0x115ab
movq 0x38(%rsp), %rax
movq %rax, 0x24(%rsp)
movl 0x34(%rsp), %esi
movl 0x30(%rsp), %edx
movq 0x24(%rsp), %rdi
callq 0x10e00
movq %rax, 0x40(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x20b30
movq %rax, 0x1c(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x20c00
testb $0x1, %al
jne 0x1159a
jmp 0x1159c
jmp 0x115cf
jmp 0x1159e
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x11539
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x20b30
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)