LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myScaled(double, double, double)
void myScaled(double x, double y, double z){
    double matrix[4][4], omatrix[4][4];
    matrix[0][0] = x; matrix[0][1] = 0; matrix[0][2] = 0; matrix[0][3] = 0;
    matrix[1][0] = 0; matrix[1][1] = y; matrix[1][2] = 0; matrix[1][3] = 0;
    matrix[2][0] = 0; matrix[2][1] = 0; matrix[2][2] = z; matrix[2][3] = 0;
    matrix[3][0] = 0; matrix[3][1] = 0; matrix[3][2] = 0; matrix[3][3] = 1;
    multiMatrix(modelMatrix, matrix, omatrix);
    for(int i = 0; i < 4; i ++){
        for(int j = 0; j < 4; j ++)
            modelMatrix[i][j] = omatrix[i][j];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x98(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x90(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x88(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x80(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x70(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x68(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x60(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x9154(%rip), %xmm0     # 0xe040
movsd %xmm0, -0x28(%rbp)
leaq -0xa0(%rbp), %rsi
leaq -0x120(%rbp), %rdx
leaq 0xf27a(%rip), %rdi      # 0x14180
callq 0x9c60
movl $0x0, -0x124(%rbp)
cmpl $0x4, -0x124(%rbp)
jge 0x4f9a
movl $0x0, -0x128(%rbp)
cmpl $0x4, -0x128(%rbp)
jge 0x4f84
movslq -0x124(%rbp), %rcx
leaq -0x120(%rbp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x128(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movslq -0x124(%rbp), %rcx
leaq 0xf220(%rip), %rax      # 0x14180
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x128(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x128(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x128(%rbp)
jmp 0x4f28
jmp 0x4f86
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0x4f15
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myPushMatrix()
void myPushMatrix(){
    double** matrix = new double*[4];
    matrix[0] = new double[4];
    matrix[1] = new double[4];
    matrix[2] = new double[4];
    matrix[3] = new double[4];
    for(int i = 0; i < 4; i ++){
        for(int j = 0; j < 4; j ++)
            matrix[i][j] = modelMatrix[i][j];
    }
    modelMatrixStack.push(matrix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x1030
movq %rax, -0x8(%rbp)
movl $0x20, %edi
callq 0x1030
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x20, %edi
callq 0x1030
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x20, %edi
callq 0x1030
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x20, %edi
callq 0x1030
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x592b
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0x591e
movslq -0xc(%rbp), %rcx
leaq 0xe892(%rip), %rax      # 0x14180
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x58dd
jmp 0x5920
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x58d0
leaq 0xe7f6(%rip), %rdi      # 0x14128
leaq -0x8(%rbp), %rsi
callq 0x6020
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myPopMatrix()
void myPopMatrix(){
    double** top = modelMatrixStack.top();
    for(int i = 0; i < 4; i ++){
        for(int j = 0; j < 4; j ++)
            modelMatrix[i][j] = top[i][j];
    }
    delete top;
    modelMatrixStack.pop();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xe7c9(%rip), %rdi      # 0x14128
callq 0x6050
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x59cd
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0x59c0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movslq -0xc(%rbp), %rcx
leaq 0xe7db(%rip), %rax      # 0x14180
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x597f
jmp 0x59c2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5972
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x59e9
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x1130
leaq 0xe738(%rip), %rdi      # 0x14128
callq 0x6070
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: mySwapBuffers()
void mySwapBuffers(){
    char s[10];
    sprintf(s, "%03d.ppm", frame);
    FILE *fp = fopen(s, "wb");
    (void) fprintf(fp, "P1\n%d %d\n", dimx, dimy);
    for(int i = 0; i < dimx*dimy; i++){
        (void) fprintf(fp, "%d", frameBuffer[i]);
    }
    frame++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0xa(%rbp), %rdi
leaq 0xe83d(%rip), %rax      # 0x14250
movl (%rax), %edx
leaq 0x8a94(%rip), %rsi      # 0xe4b0
movb $0x0, %al
callq 0x1040
leaq -0xa(%rbp), %rdi
leaq 0x8a8b(%rip), %rsi      # 0xe4b9
callq 0x1140
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xe806(%rip), %rax      # 0x14248
movl (%rax), %edx
leaq 0xe801(%rip), %rax      # 0x1424c
movl (%rax), %ecx
leaq 0x8a68(%rip), %rsi      # 0xe4bc
movb $0x0, %al
callq 0x1150
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0xe7dc(%rip), %rcx      # 0x14248
movl (%rcx), %ecx
leaq 0xe7d7(%rip), %rdx      # 0x1424c
imull (%rdx), %ecx
cmpl %ecx, %eax
jge 0x5aaa
movq -0x18(%rbp), %rdi
leaq 0xe7b1(%rip), %rax      # 0x14238
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x8a2e(%rip), %rsi      # 0xe4c6
movb $0x0, %al
callq 0x1150
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5a62
leaq 0xe79f(%rip), %rax      # 0x14250
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xe793(%rip), %rax      # 0x14250
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: XuhuiSun95[P]My-OpenGL/primitive.cpp
// Function: modelTransform(vertex)
vertex modelTransform(vertex v){
    double ox = modelMatrix[0][0] * v.x + modelMatrix[0][1] * v.y + modelMatrix[0][2] * v.z + modelMatrix[0][3];
    double oy = modelMatrix[1][0] * v.x + modelMatrix[1][1] * v.y + modelMatrix[1][2] * v.z + modelMatrix[1][3];
    double oz = modelMatrix[2][0] * v.x + modelMatrix[2][1] * v.y + modelMatrix[2][2] * v.z + modelMatrix[2][3];
    double oc = modelMatrix[3][0] * v.x + modelMatrix[3][1] * v.y + modelMatrix[3][2] * v.z + modelMatrix[3][3];
    return vertex(ox/oc, oy/oc, oz/oc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x10(%rbp), %rax
movsd 0xa6a5(%rip), %xmm1     # 0x14180
movsd (%rax), %xmm2
movsd 0xa6a1(%rip), %xmm0     # 0x14188
mulsd 0x8(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xa694(%rip), %xmm0     # 0x14190
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd 0xa687(%rip), %xmm0     # 0x14198
movsd %xmm0, -0x8(%rbp)
movsd 0xa682(%rip), %xmm1     # 0x141a0
movsd (%rax), %xmm2
movsd 0xa67e(%rip), %xmm0     # 0x141a8
mulsd 0x8(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xa671(%rip), %xmm0     # 0x141b0
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd 0xa664(%rip), %xmm0     # 0x141b8
movsd %xmm0, -0x10(%rbp)
movsd 0xa65f(%rip), %xmm1     # 0x141c0
movsd (%rax), %xmm2
movsd 0xa65b(%rip), %xmm0     # 0x141c8
mulsd 0x8(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xa64e(%rip), %xmm0     # 0x141d0
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd 0xa641(%rip), %xmm0     # 0x141d8
movsd %xmm0, -0x18(%rbp)
movsd 0xa63c(%rip), %xmm1     # 0x141e0
movsd (%rax), %xmm2
movsd 0xa638(%rip), %xmm0     # 0x141e8
mulsd 0x8(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0xa62b(%rip), %xmm0     # 0x141f0
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd 0xa61e(%rip), %xmm0     # 0x141f8
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
divsd -0x20(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
divsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
divsd -0x20(%rbp), %xmm2
callq 0x5af0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: XuhuiSun95[P]My-OpenGL/primitive.cpp
// Function: multiMatrix(double (*) [4], double (*) [4], double (*) [4])
void multiMatrix(double imat1[4][4], double imat2[4][4], double omat[4][4]){
    for(int i = 0; i < 4; i++){
        for(int j = 0; j < 4; j++){
            omat[i][j] = 0;
            for(int k = 0; k < 4; k++)
                omat[i][j] += imat1[i][k] * imat2[k][j];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x9d3a
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x9d2a
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0x9d1a
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9cb4
jmp 0x9d1c
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9c88
jmp 0x9d2c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9c77
popq %rbp
retq
nopl (%rax)
// File: XuhuiSun95[P]My-OpenGL/primitive.cpp
// Function: inputBuffer(int, int, double)
void inputBuffer(int x, int y, double zDepth){
    int pixel = (y - 1) * dimx + x;
    if(x > 0 && x <= dimx && y > 0 && y <= dimy && zDepth >= depthBuffer[pixel - 1]){
        frameBuffer[(pixel - 1)] = 0;
        depthBuffer[pixel - 1] = zDepth;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
imull 0xa4ec(%rip), %eax      # 0x14248
addl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x9dd1
movl -0x4(%rbp), %eax
cmpl 0xa4d7(%rip), %eax      # 0x14248
jg 0x9dd1
cmpl $0x0, -0x8(%rbp)
jle 0x9dd1
movl -0x8(%rbp), %eax
cmpl 0xa4ca(%rip), %eax      # 0x1424c
jg 0x9dd1
movsd -0x10(%rbp), %xmm0
movq 0xa4b0(%rip), %rax      # 0x14240
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
ucomisd (%rax,%rcx,8), %xmm0
jb 0x9dd1
movq 0xa491(%rip), %rax      # 0x14238
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
movsd -0x10(%rbp), %xmm0
movq 0xa47d(%rip), %rax      # 0x14240
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: XuhuiSun95[P]My-OpenGL/primitive.cpp
// Function: hidenSurface(int, int, double)
void hidenSurface(int x, int y, double zDepth){
    int pixel = (y - 1) * dimx + x;
    if(x > 0 && x <= dimx && y > 0 && y <= dimy && zDepth >= depthBuffer[pixel - 1]){
        frameBuffer[(pixel - 1)] = 1;
        depthBuffer[pixel - 1] = zDepth;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
imull 0xa44c(%rip), %eax      # 0x14248
addl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x9e71
movl -0x4(%rbp), %eax
cmpl 0xa437(%rip), %eax      # 0x14248
jg 0x9e71
cmpl $0x0, -0x8(%rbp)
jle 0x9e71
movl -0x8(%rbp), %eax
cmpl 0xa42a(%rip), %eax      # 0x1424c
jg 0x9e71
movsd -0x10(%rbp), %xmm0
movq 0xa410(%rip), %rax      # 0x14240
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
ucomisd (%rax,%rcx,8), %xmm0
jb 0x9e71
movq 0xa3f1(%rip), %rax      # 0x14238
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl $0x1, (%rax,%rcx,4)
movsd -0x10(%rbp), %xmm0
movq 0xa3dd(%rip), %rax      # 0x14240
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: thunlp[P]KB2E/TransE/Test_TransE.cpp
// Function: vec_output(std::vector<double, std::allocator<double>>)
void vec_output(vector<double> a)
{
	for (int i=0; i<a.size(); i++)
	{
		cout<<a[i]<<"\t";
		if (i%10==9)
			cout<<endl;
	}
	cout<<"-------------------------"<<endl;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x3e70
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x297b
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x3e90
movsd (%rax), %xmm0
movq 0x1b6a7(%rip), %rdi     # 0x1dfd8
callq 0x2370
movq %rax, %rdi
leaq 0x12715(%rip), %rsi     # 0x15055
callq 0x21c0
movl 0x1c(%rsp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x9, %edx
jne 0x2969
movq 0x1b67b(%rip), %rdi     # 0x1dfd8
movq 0x1b65c(%rip), %rsi     # 0x1dfc0
callq 0x2210
jmp 0x296b
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x28f6
movq 0x1b656(%rip), %rdi     # 0x1dfd8
leaq 0x126ce(%rip), %rsi     # 0x15057
callq 0x21c0
movq %rax, %rdi
movq 0x1b628(%rip), %rsi     # 0x1dfc0
callq 0x2210
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: thunlp[P]KB2E/TransE/Test_TransE.cpp
// Function: main
int main(int argc,char**argv)
{
    if (argc<2)
        return 0;
    else
    {
        version = argv[1];
        prepare();
        test.run();
    }
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x2, 0x10(%rsp)
jge 0x3cb6
movl $0x0, 0x14(%rsp)
jmp 0x3cdc
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x1a542(%rip), %rdi     # 0x1e208
callq 0x2290
callq 0x2a40
leaq 0x4b499(%rip), %rdi     # 0x4f170
callq 0x45c0
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: thunlp[P]KB2E/TransE/Test_TransE.cpp
// Function: Test::calc_sum(int, int, int)
double calc_sum(int e1,int e2,int rel)
    {
        double sum=0;
        if (L1_flag)
        	for (int ii=0; ii<n; ii++)
            sum+=-fabs(entity_vec[e2][ii]-entity_vec[e1][ii]-relation_vec[rel][ii]);
        else
        for (int ii=0; ii<n; ii++)
            sum+=-sqr(entity_vec[e2][ii]-entity_vec[e1][ii]-relation_vec[rel][ii]);
        return sum;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
testb $0x1, 0x143d1(%rip)     # 0x1e1e0
je 0x9ef0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x143bd(%rip), %eax     # 0x1e1e4
jge 0x9eeb
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
movslq 0x48(%rsp), %rsi
callq 0x9bf0
movq %rax, %rdi
movslq 0x34(%rsp), %rsi
callq 0x3e90
movq 0x28(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
addq $0x18, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x9bf0
movq %rax, %rdi
movslq 0x34(%rsp), %rsi
callq 0x3e90
movsd 0x18(%rsp), %xmm0
movq 0x28(%rsp), %rdi
subsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movslq 0x44(%rsp), %rsi
callq 0x9bf0
movq %rax, %rdi
movslq 0x34(%rsp), %rsi
callq 0x3e90
movsd 0x20(%rsp), %xmm0
subsd (%rax), %xmm0
movaps 0xb18c(%rip), %xmm1     # 0x15040
pand %xmm1, %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x9e1d
jmp 0x9fc2
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x142e2(%rip), %eax     # 0x1e1e4
jge 0x9fc0
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
movslq 0x48(%rsp), %rsi
callq 0x9bf0
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x3e90
movq 0x28(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x18, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x9bf0
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x3e90
movsd 0x8(%rsp), %xmm0
movq 0x28(%rsp), %rdi
subsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movslq 0x44(%rsp), %rsi
callq 0x9bf0
movq %rax, %rdi
movslq 0x30(%rsp), %rsi
callq 0x3e90
movsd 0x10(%rsp), %xmm0
subsd (%rax), %xmm0
callq 0x29b0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x9ef8
jmp 0x9fc2
movsd 0x38(%rsp), %xmm0
addq $0x58, %rsp
retq
nopl (%rax)
// File: kaityo256[P]cps/cps.cpp
// Function: worker(int)
void worker(const int rank) {
  while (true) {
    int send = 10;
    int len = 0;
    MPI_Status st;
    // Sends dummy data to notify that communication is ready.
    MPI_Send(&send, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
    // Recieve the length of a command
    MPI_Recv(&len, 1, MPI_INT, 0, 0, MPI_COMM_WORLD, &st);
    // If the length is zero, all tasks are completed.
    if (len == 0) {
      debug_printf("Finish OK: %d\n", rank);
      break;
    }
    std::unique_ptr<char[]> buf(new char[len]);
    MPI_Recv(buf.get(), len, MPI_CHAR, 0, 0, MPI_COMM_WORLD, &st);
    std::string recv_string = buf.get();
    debug_printf("%d: Recieved %s\n", rank, recv_string.c_str());
    std::system(recv_string.c_str());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
movl $0xa, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x8(%rbp), %rdi
movl $0x1, %esi
movq 0x1187c(%rip), %rdx     # 0x1afc8
xorl %r8d, %r8d
movq 0x1184a(%rip), %r9      # 0x1afa0
movl %r8d, %ecx
callq 0x81e0
leaq -0xc(%rbp), %rdi
movl $0x1, %esi
movq 0x1185a(%rip), %rdx     # 0x1afc8
xorl %r8d, %r8d
movq 0x11828(%rip), %r9      # 0x1afa0
leaq -0x28(%rbp), %rax
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x84e0
cmpl $0x0, -0xc(%rbp)
jne 0x97a3
leaq 0x995b(%rip), %rdi      # 0x130f0
leaq -0x4(%rbp), %rsi
callq 0xa950
jmp 0x98cc
movslq -0xc(%rbp), %rdi
testq %rdi, %rdi
movq $-0x1, %rax
cmovsq %rax, %rdi
callq 0x8040
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xa960
movq -0x78(%rbp), %rdi
callq 0xa990
movq %rax, %rdi
movl -0xc(%rbp), %esi
movq %rsp, %rax
leaq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq 0x1179e(%rip), %rdx     # 0x1af88
movq 0x117af(%rip), %r9      # 0x1afa0
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x84e0
jmp 0x97fe
leaq -0x30(%rbp), %rdi
callq 0xa990
movq %rax, -0x88(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x8b50
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x8850
jmp 0x9831
leaq -0x61(%rbp), %rdi
callq 0x8680
leaq -0x60(%rbp), %rdi
callq 0x8210
movq %rax, -0x70(%rbp)
leaq 0x98b1(%rip), %rdi      # 0x130ff
leaq -0x4(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xa9c0
jmp 0x985d
leaq -0x60(%rbp), %rdi
callq 0x8210
movq %rax, %rdi
callq 0x8500
jmp 0x9870
leaq -0x60(%rbp), %rdi
callq 0x8380
leaq -0x30(%rbp), %rdi
callq 0xa9e0
jmp 0x972e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x98c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x8680
jmp 0x98c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8380
leaq -0x30(%rbp), %rdi
callq 0xa9e0
jmp 0x98d5
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x8b40
nop
// File: kaityo256[P]cps/cps.cpp
// Function: main
int main(int argc, char **argv) {
  MPI_Init(&argc, &argv);
  int rank, procs;
  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  MPI_Comm_size(MPI_COMM_WORLD, &procs);

  if (argc < 2 || procs < 2) {
    if (rank == 0) {
      fprintf(stderr, "Usage: mpirun -np num_procs ./cps tasklist\n");
      fprintf(stderr, "num_procs must be 2 or more.\n");
    }
    MPI_Finalize();
    return 1;
  }

  int is_ready = loadfile(argc, argv);
  int all_ready = 0;
  MPI_Allreduce(&is_ready, &all_ready, 1, MPI_INT, MPI_LAND, MPI_COMM_WORLD);

  if (all_ready) {
    if (rank == 0) {
      manager(procs);
    } else {
      worker(rank);
    }
  }

  MPI_Finalize();
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x88e0
movq 0x113d6(%rip), %rdi     # 0x1afa0
leaq -0x14(%rbp), %rsi
callq 0x88d0
movq 0x113c6(%rip), %rdi     # 0x1afa0
leaq -0x18(%rbp), %rsi
callq 0x8700
cmpl $0x2, -0x8(%rbp)
jl 0x9bef
cmpl $0x2, -0x18(%rbp)
jge 0x9c33
cmpl $0x0, -0x14(%rbp)
jne 0x9c25
movq 0x113d4(%rip), %rax     # 0x1afd0
movq (%rax), %rdi
leaq 0x9531(%rip), %rsi      # 0x13137
movb $0x0, %al
callq 0x8920
movq 0x113bc(%rip), %rax     # 0x1afd0
movq (%rax), %rdi
leaq 0x9545(%rip), %rsi      # 0x13163
movb $0x0, %al
callq 0x8920
callq 0x8460
movl $0x1, -0x4(%rbp)
jmp 0x9c9c
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x98e0
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x1, %edx
movq 0x1136b(%rip), %rcx     # 0x1afc8
movq 0x11344(%rip), %r8      # 0x1afa8
movq 0x11335(%rip), %r9      # 0x1afa0
callq 0x8750
cmpl $0x0, -0x20(%rbp)
je 0x9c90
cmpl $0x0, -0x14(%rbp)
jne 0x9c86
movl -0x18(%rbp), %edi
callq 0x8f10
jmp 0x9c8e
movl -0x14(%rbp), %edi
callq 0x9720
jmp 0x9c90
callq 0x8460
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: king1600[P]cordpp/./include/collection.h
// Function: cordpp::Collection<cordpp::Overwrite>::Collection()
Collection() {
      pos = 0;
      marking = 0;
      csize = 10;
      frag_rate = 3;
      frag_count = 0;
      list = new CollectionItem[csize];
      for (slot = 0; slot < csize; slot++)
        list[slot] = {nullptr, slot, 0};
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, (%rax)
movq $0x0, 0x18(%rax)
movq $0xa, 0x10(%rax)
movq $0x3, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq 0x10(%rax), %rax
movl $0x18, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xc640
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
jae 0x10a72
movq -0x28(%rbp), %rcx
movq $0x0, -0x20(%rbp)
movq 0x8(%rcx), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq 0x30(%rcx), %rax
imulq $0x18, 0x8(%rcx), %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x10a13
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: king1600[P]cordpp/./include/collection.h
// Function: cordpp::Collection<cordpp::Overwrite>::cache_size(unsigned long)
const size_t cache_size(const size_t new_size = 0) {
      if (new_size < 1)
        return csize;
      CollectionItem *new_list = new CollectionItem[new_size];
      for (slot = 0; slot < new_size; slot++)
        new_list[slot] = slot <= csize ? 
          list[csize - slot] : CollectionItem{nullptr, slot, 0};
      csize = new_size;
      delete list;
      list = new_list;
      return csize;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x1, -0x18(%rbp)
jae 0x10ab0
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x10bcc
movq -0x18(%rbp), %rax
movl $0x18, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xc640
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq $0x0, 0x8(%rax)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jae 0x10b90
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
ja 0x10b38
movq -0x40(%rbp), %rdx
movq 0x30(%rdx), %rax
movq 0x10(%rdx), %rcx
subq 0x8(%rdx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x10b54
movq -0x40(%rbp), %rax
movq $0x0, -0x38(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
imulq $0x18, 0x8(%rcx), %rcx
addq %rcx, %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x10ae8
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x10bb8
movq -0x48(%rbp), %rdi
movl $0x18, %esi
callq 0xc1b0
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: king1600[P]cordpp/./include/collection.h
// Function: cordpp::Collection<cordpp::Overwrite>::clear()
void clear() {
      pos = 0;
      for (slot = 0; slot < csize; slot++) {
        if (list[slot].item != nullptr) {
          delete list[slot].item;
          list[slot].marker = 0;
        }
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
jae 0x10fda
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rax
imulq $0x18, 0x8(%rcx), %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x10fc3
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rax
imulq $0x18, 0x8(%rcx), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x10fab
movq -0x18(%rbp), %rdi
callq 0x10fe0
movq -0x18(%rbp), %rdi
movl $0x30, %esi
callq 0xc1b0
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rax
imulq $0x18, 0x8(%rcx), %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
jmp 0x10fc5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x10f53
addq $0x20, %rsp
popq %rbp
retq
// File: king1600[P]cordpp/src/client.cc
// Function: cordpp::Client::login(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Client::login(const std::string &_token) {
  // set the bot token
  token = _token;
  _api->set_token(token);

  // fetch the gateway url
  _api->get("/gateway/bot", "", {}, [this](const Json &data) {
    max_shards = (max_shards < 1) ? data["shards"].get<uint8_t>() : max_shards;
    std::string url = data["url"].get<std::string>();
    url = url.substr(url.find("://") + 3);
    _gateway = std::make_unique<Gateway>(this, url, shard_id, max_shards);
  });

  // run the event loop
  service.run();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
movq -0x10(%rbp), %rsi
addq $0x50, %rdi
movq %rdi, -0xc8(%rbp)
callq 0xcec0
movq -0xd0(%rbp), %rdi
addq $0x8, %rdi
movq %rdi, -0xc0(%rbp)
callq 0x12500
movq -0xc8(%rbp), %rsi
movq %rax, %rdi
callq 0x4ee30
movq -0xc0(%rbp), %rdi
callq 0x12500
movq %rax, -0xb8(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xcc80
movq -0xb0(%rbp), %rdx
leaq 0x7e0a4(%rip), %rsi     # 0x8f2ad
leaq -0x30(%rbp), %rdi
callq 0x107e0
jmp 0x11214
leaq -0x69(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0xcc80
movq -0xd8(%rbp), %rdx
leaq 0x8301e(%rip), %rsi     # 0x94250
leaq -0x68(%rbp), %rdi
callq 0x107e0
jmp 0x1123d
xorl %eax, %eax
movl %eax, %esi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x12520
movq -0xd0(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
leaq -0xa8(%rbp), %rsi
callq 0x11360
movq -0xb8(%rbp), %rdi
movq -0xe8(%rbp), %rcx
movq -0xe0(%rbp), %r8
leaq -0x30(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x4ee60
jmp 0x1129d
leaq -0xa0(%rbp), %rdi
callq 0x122d0
leaq -0x80(%rbp), %rdi
callq 0x12560
leaq -0x68(%rbp), %rdi
callq 0xcfb8
leaq -0x69(%rbp), %rdi
callq 0xcfa0
leaq -0x30(%rbp), %rdi
callq 0xcfb8
leaq -0x31(%rbp), %rdi
callq 0xcfa0
movq -0xd0(%rbp), %rdi
addq $0x18, %rdi
callq 0x5a1d0
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x11347
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x11335
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x122d0
leaq -0x80(%rbp), %rdi
callq 0x12560
leaq -0x68(%rbp), %rdi
callq 0xcfb8
leaq -0x69(%rbp), %rdi
callq 0xcfa0
leaq -0x30(%rbp), %rdi
callq 0xcfb8
leaq -0x31(%rbp), %rdi
callq 0xcfa0
movq -0x40(%rbp), %rdi
callq 0xc8c0
nopl (%rax)
// File: king1600[P]cordpp/./include/json.h
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::json_value::destroy(nlohmann::detail::value_t)
void destroy(value_t t)
        {
            switch (t)
            {
                case value_t::object:
                {
                    AllocatorType<object_t> alloc;
                    alloc.destroy(object);
                    alloc.deallocate(object, 1);
                    break;
                }

                case value_t::array:
                {
                    AllocatorType<array_t> alloc;
                    alloc.destroy(array);
                    alloc.deallocate(array, 1);
                    break;
                }

                case value_t::string:
                {
                    AllocatorType<string_t> alloc;
                    alloc.destroy(string);
                    alloc.deallocate(string, 1);
                    break;
                }

                default:
                {
                    break;
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x1f(%rbp)
subb $0x1, %al
je 0x1bbaf
jmp 0x1bb96
movb -0x1f(%rbp), %al
subb $0x2, %al
je 0x1bc0b
jmp 0x1bb9f
movb -0x1f(%rbp), %al
subb $0x3, %al
je 0x1bc61
jmp 0x1bc9a
leaq -0xa(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1bcb0
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
callq 0x1bcd0
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
movl $0x1, %edx
callq 0x1bcf0
jmp 0x1bbe3
leaq -0xa(%rbp), %rdi
callq 0x1bd20
jmp 0x1bc9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xa(%rbp), %rdi
callq 0x1bd20
jmp 0x1bca2
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1bd40
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rdi
movq (%rax), %rsi
callq 0x1bd60
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rdi
movq (%rax), %rsi
movl $0x1, %edx
callq 0x1bd80
jmp 0x1bc3f
leaq -0x1d(%rbp), %rdi
callq 0x1bdb0
jmp 0x1bc9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x1bdb0
jmp 0x1bca2
leaq -0x1e(%rbp), %rdi
callq 0x1bdd0
movq -0x28(%rbp), %rax
movq (%rax), %rsi
leaq -0x1e(%rbp), %rdi
callq 0x1bdf0
movq -0x28(%rbp), %rax
movq (%rax), %rsi
leaq -0x1e(%rbp), %rdi
movl $0x1, %edx
callq 0x15be0
leaq -0x1e(%rbp), %rdi
callq 0x1be10
jmp 0x1bc9c
jmp 0x1bc9c
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xc8c0
nopl (%rax,%rax)
// File: king1600[P]cordpp/src/date.cc
// Function: cordpp::Date::toString[abi:cxx11]() const
const std::string Date::toString() const {
  char t[126] = {0};
  static const char* format = "%Y-%m-%dT%H:%M:%SZ";
  std::strftime(t, sizeof(t), format, &dtime);
  return std::string(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, -0xd0(%rbp)
movups %xmm0, -0x22(%rbp)
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
movq 0xbbecc(%rip), %rdx     # 0xdc848
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movl $0x7e, %esi
callq 0xcb40
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xcc80
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
callq 0x107e0
jmp 0x209c3
leaq -0x91(%rbp), %rdi
callq 0xcfa0
movq -0xd8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x91(%rbp), %rdi
callq 0xcfa0
movq -0xa0(%rbp), %rdi
callq 0xc8c0
nopl (%rax)
// File: king1600[P]cordpp/src/gateway.cc
// Function: cordpp::Gateway::Gateway(cordpp::Client*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char&, unsigned char&)
Gateway::Gateway(Client *client,
  const std::string &host, uint8_t &id, uint8_t &max)
  : shard_id(id), max_shards(max), beat(client->service.get())
{
  this->host_url = host; 
  this->client = client;
  this->resume_delay = 0;
  this->is_resume = false;
  conn = std::make_unique<WebsockClient>(client->service);
  connect(); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, (%rdi)
movq -0x28(%rbp), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x70(%rbp)
callq 0xc4e0
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x68(%rbp)
callq 0x28f80
movq -0x58(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x60(%rbp)
callq 0xc4e0
movq -0x58(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x5a210
movq %rax, -0x48(%rbp)
jmp 0x219e4
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x28fb0
jmp 0x219f7
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rdi
callq 0xcec0
jmp 0x21a0a
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0xe8(%rax)
movl $0x0, 0x4c(%rax)
movb $0x0, 0x38(%rax)
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
leaq -0x40(%rbp), %rdi
callq 0x28fe0
jmp 0x21a37
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0x78(%rbp)
callq 0x29060
movq -0x78(%rbp), %rdi
callq 0x1c6e0
movq -0x58(%rbp), %rdi
callq 0x21ab0
jmp 0x21a60
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x21a8c
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x166e0
movq -0x60(%rbp), %rdi
callq 0xcfb8
movq -0x68(%rbp), %rdi
callq 0x1c6e0
movq -0x70(%rbp), %rdi
callq 0xcfb8
movq -0x30(%rbp), %rdi
callq 0xc8c0
// File: king1600[P]cordpp/src/gateway.cc
// Function: cordpp::Gateway::heartbeat()
void Gateway::heartbeat() {
  // stop beating if websocket is not connected
  if (conn->state != WebsockState::open) {
    return;

  // no heartbeat ack (zombie conneciton), reconnect & resume
  } else if (!heartbeat_acked) {
    is_resume = true;
    conn->close(1011, "heartbeat stopped");

  // process heartbeat
  } else {
    Json sequence_data;
    if (sequence > 0)
      sequence_data = sequence;
    else
      sequence_data = nullptr;
    send(GatewayOp::Heartbeat, sequence_data);
    heartbeat_acked = false;
    beat.expires_from_now(boost::posix_time::millisec(heartbeat_interval));
    beat.async_wait([this](const Error &err) {
      if (!err) heartbeat();
    });
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x30, %rdi
callq 0x29600
cmpl $0x0, 0x398(%rax)
je 0x22301
jmp 0x224b8
movq -0x88(%rbp), %rax
testb $0x1, 0x48(%rax)
jne 0x223b5
movq -0x88(%rbp), %rdi
movb $0x1, 0x38(%rdi)
addq $0x30, %rdi
callq 0x29600
movq %rax, -0x98(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xcc80
movq -0x90(%rbp), %rdx
leaq 0x6f138(%rip), %rsi     # 0x91483
leaq -0x28(%rbp), %rdi
callq 0x107e0
jmp 0x22356
movq -0x98(%rbp), %rdi
movl $0x3f3, %esi            # imm = 0x3F3
leaq -0x28(%rbp), %rdx
callq 0x895d0
jmp 0x2236d
leaq -0x28(%rbp), %rdi
callq 0xcfb8
leaq -0x29(%rbp), %rdi
callq 0xcfa0
jmp 0x224b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x223a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xcfb8
leaq -0x29(%rbp), %rdi
callq 0xcfa0
jmp 0x224c1
leaq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12520
movq -0x88(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jbe 0x223fc
movq -0x88(%rbp), %rsi
addq $0x40, %rsi
leaq -0x60(%rbp), %rdi
callq 0x29620
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x29670
leaq -0x60(%rbp), %rdi
callq 0x12560
jmp 0x2241f
leaq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12520
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x29670
leaq -0x70(%rbp), %rdi
callq 0x12560
movq -0x88(%rbp), %rdi
movl $0x1, %esi
leaq -0x50(%rbp), %rdx
callq 0x21ce0
jmp 0x22436
movq -0x88(%rbp), %rsi
movb $0x0, 0x48(%rsi)
movq %rsi, %rax
addq $0x70, %rax
movq %rax, -0xa0(%rbp)
addq $0xe0, %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x78(%rbp), %rdi
callq 0x29750
jmp 0x22465
movq -0xa0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x296e0
jmp 0x22477
movq -0x88(%rbp), %rax
movq %rax, %rdi
addq $0x70, %rdi
movq %rax, -0x80(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x224d0
jmp 0x22494
leaq -0x50(%rbp), %rdi
callq 0x12560
jmp 0x224b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x12560
jmp 0x224c1
jmp 0x224b8
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xc8c0
nopw (%rax,%rax)
// File: king1600[P]cordpp/./include/json.h
// Function: nlohmann::detail::serializer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::bytes_following(unsigned char)
static constexpr std::size_t bytes_following(const uint8_t u)
    {
        return ((0 <= u and u <= 127) ? 0
                : ((192 <= u and u <= 223) ? 1
                   : ((224 <= u and u <= 239) ? 2
                      : ((240 <= u and u <= 247) ? 3 : std::string::npos))));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x300c8
movzbl -0x1(%rbp), %eax
cmpl $0x7f, %eax
jg 0x300c8
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0x30159
movzbl -0x1(%rbp), %ecx
movl $0xc0, %eax
cmpl %ecx, %eax
jg 0x300eb
movzbl -0x1(%rbp), %eax
cmpl $0xdf, %eax
jg 0x300eb
movl $0x1, %eax
movq %rax, -0x18(%rbp)
jmp 0x30151
movzbl -0x1(%rbp), %ecx
movl $0xe0, %eax
cmpl %ecx, %eax
jg 0x3010e
movzbl -0x1(%rbp), %eax
cmpl $0xef, %eax
jg 0x3010e
movl $0x2, %eax
movq %rax, -0x20(%rbp)
jmp 0x30149
movzbl -0x1(%rbp), %edx
xorl %eax, %eax
movl $0xf0, %ecx
cmpl %edx, %ecx
movb %al, -0x21(%rbp)
jg 0x3012f
movzbl -0x1(%rbp), %eax
cmpl $0xf7, %eax
setle %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %dl
movq $-0x1, %rax
movl $0x3, %ecx
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: king1600[P]cordpp/./include/json.h
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::operator[](unsigned long) const
const_reference operator[](size_type idx) const
    {
        // const operator[] only works for arrays
        if (JSON_LIKELY(is_array()))
        {
            return m_value.array->operator[](idx);
        }

        JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x401e0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x402ca
jmp 0x402e4
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40400
addq $0x80, %rsp
popq %rbp
retq
movb $0x1, -0x5e(%rbp)
movl $0x20, %edi
callq 0xc560
movq -0x68(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x1f990
movq %rax, -0x70(%rbp)
jmp 0x40305
leaq -0x5d(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xcc80
movq -0x70(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x107e0
jmp 0x40325
leaq 0x4fb4b(%rip), %rsi     # 0x8fe77
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x1f940
jmp 0x4033b
movq -0x78(%rbp), %rdi
movl $0x131, %esi            # imm = 0x131
leaq -0x30(%rbp), %rdx
callq 0x1f7f0
jmp 0x4034f
movq -0x78(%rbp), %rdi
movb $0x0, -0x5e(%rbp)
leaq 0x9a32a(%rip), %rsi     # 0xda688
leaq -0x20945(%rip), %rdx    # 0x1fa20
callq 0xc890
jmp 0x403d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x403bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x403b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x403ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xcfb8
leaq -0x50(%rbp), %rdi
callq 0xcfb8
leaq -0x5d(%rbp), %rdi
callq 0xcfa0
testb $0x1, -0x5e(%rbp)
jne 0x403c5
jmp 0x403ce
movq -0x78(%rbp), %rdi
callq 0xcb30
jmp 0x403d0
movq -0x58(%rbp), %rdi
callq 0xc8c0
nopl (%rax)
// File: king1600[P]cordpp/./include/json.h
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
iterator find(typename object_t::key_type key)
    {
        auto result = end();

        if (is_object())
        {
            result.m_it.object_iterator = m_value.object->find(key);
        }

        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x28(%rbp)
callq 0x44f90
movq -0x28(%rbp), %rdi
callq 0x1f720
testb $0x1, %al
jne 0x44f2f
jmp 0x44f53
movq -0x40(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1f770
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: king1600[P]cordpp/./include/json.h
// Function: nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::add(int)
void add(int c)
    {
        // resize yytext if necessary; this condition is deemed unlikely,
        // because we start with a 1024-byte buffer
        if (JSON_UNLIKELY((yylen + 1 > yytext.capacity())))
        {
            yytext.resize(2 * yytext.capacity(), '\0');
        }
        assert(yylen < yytext.size());
        yytext[yylen++] = static_cast<char>(c);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq 0x40(%rdi), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
addq $0x28, %rdi
callq 0x47aa0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
seta %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x476f3
jmp 0x47722
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
addq $0x28, %rdi
callq 0x47aa0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
shlq %rsi
movb $0x0, -0xd(%rbp)
leaq -0xd(%rbp), %rdx
callq 0x47ac0
movq -0x20(%rbp), %rdi
movq 0x40(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x28, %rdi
callq 0x191c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x47745
jmp 0x47764
leaq 0x4b2ef(%rip), %rdi     # 0x92a3b
leaq 0x47ef6(%rip), %rsi     # 0x8f649
movl $0xa3b, %edx            # imm = 0xA3B
leaq 0x4b2f2(%rip), %rcx     # 0x92a51
callq 0xc290
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movb %cl, -0x31(%rbp)
movq %rax, %rdi
addq $0x28, %rdi
movq 0x40(%rax), %rsi
movq %rsi, %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
callq 0x18d50
movb -0x31(%rbp), %cl
movb %cl, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: king1600[P]cordpp/src/guild.cc
// Function: cordpp::Guild::Guild()
Guild::Guild() : Item() {
  _roles.cache_size(10);
  _emojis.cache_size(10);
  _members.cache_size(10);
  _channels.cache_size(10);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq $0x0, (%rdi)
addq $0x8, %rdi
callq 0x20660
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x48(%rbp)
callq 0xc4e0
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x40(%rbp)
callq 0xc4e0
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0x38(%rbp)
callq 0xc4e0
movq -0x28(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0x30(%rbp)
callq 0xc4e0
movq -0x28(%rbp), %rdi
addq $0xf0, %rdi
movq %rdi, -0x20(%rbp)
callq 0x4dc30
jmp 0x4d7a4
movq -0x28(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
movq %rdi, -0x50(%rbp)
callq 0x4dd10
jmp 0x4d7ba
movq -0x28(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
movq %rdi, -0x58(%rbp)
callq 0x4ddf0
jmp 0x4d7d0
movq -0x28(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
movq %rdi, -0x60(%rbp)
callq 0x4ded0
jmp 0x4d7e6
movq -0x28(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
movq %rdi, -0x70(%rbp)
callq 0x4dfb0
movq -0x28(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
movq %rdi, -0x68(%rbp)
callq 0x4dfd0
movq -0x28(%rbp), %rdi
addq $0xf0, %rdi
movl $0xa, %esi
callq 0x4dff0
jmp 0x4d825
movq -0x28(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
movl $0xa, %esi
callq 0x4e150
jmp 0x4d83c
movq -0x28(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
movl $0xa, %esi
callq 0x4e2b0
jmp 0x4d853
movq -0x28(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
movl $0xa, %esi
callq 0x4e410
jmp 0x4d86a
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x4d8ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x4d8e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x4d8d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x4d8cf
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x4e570
movq -0x70(%rbp), %rdi
callq 0x15530
movq -0x60(%rbp), %rdi
callq 0x4e5d0
movq -0x58(%rbp), %rdi
callq 0x4e620
movq -0x50(%rbp), %rdi
callq 0x4e670
movq -0x20(%rbp), %rdi
callq 0x4e6c0
movq -0x30(%rbp), %rdi
callq 0xcfb8
movq -0x38(%rbp), %rdi
callq 0xcfb8
movq -0x40(%rbp), %rdi
callq 0xcfb8
movq -0x48(%rbp), %rdi
callq 0xcfb8
movq -0x10(%rbp), %rdi
callq 0xc8c0
nopw (%rax,%rax)