LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/XuhuiSun95[P]My-OpenGL/myGL.cpp
// Function: myTranslated(double, double, double)
void myTranslated(double x, double y, double z){
    double matrix[4][4], omatrix[4][4];
    matrix[0][0] = 1; matrix[0][1] = 0; matrix[0][2] = 0; matrix[0][3] = x;
    matrix[1][0] = 0; matrix[1][1] = 1; matrix[1][2] = 0; matrix[1][3] = y;
    matrix[2][0] = 0; matrix[2][1] = 0; matrix[2][2] = 1; matrix[2][3] = z;
    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
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq -0x110(%rbp), %rsi
movq %rax, (%rsi)
xorps %xmm3, %xmm3
movups %xmm3, 0x8(%rsi)
movsd %xmm0, 0x18(%rsi)
andq $0x0, 0x20(%rsi)
movq %rax, 0x28(%rsi)
andq $0x0, 0x30(%rsi)
movsd %xmm1, 0x38(%rsi)
movaps %xmm3, 0x40(%rsi)
movq %rax, 0x50(%rsi)
movsd %xmm2, 0x58(%rsi)
movaps %xmm3, 0x60(%rsi)
andq $0x0, 0x70(%rsi)
movq %rax, 0x78(%rsi)
leaq 0x5b3d(%rip), %rbx      # 0x9160
leaq -0x90(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x490c
xorl %eax, %eax
cmpq $0x4, %rax
je 0x3662
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x3655
movsd (%r14,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
jmp 0x363f
incq %rax
addq $0x20, %r14
addq $0x20, %rbx
jmp 0x3637
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
leaq -0x110(%rbp), %rsi
movsd %xmm0, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
movups %xmm0, 0x18(%rsi)
movsd %xmm1, 0x28(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movsd %xmm2, 0x50(%rsi)
movups %xmm0, 0x58(%rsi)
movups %xmm0, 0x68(%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rsi)
leaq 0x5a49(%rip), %rbx      # 0x9160
leaq -0x90(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x490c
xorl %eax, %eax
cmpq $0x4, %rax
je 0x3756
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x3749
movsd (%r14,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
jmp 0x3733
incq %rax
addq $0x20, %r14
addq $0x20, %rbx
jmp 0x372b
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $0x20
popq %r14
movq %r14, %rdi
callq 0x1030
movq %rax, %rbx
movq %rax, -0x18(%rbp)
movq %r14, %rdi
callq 0x1030
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x1030
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x1030
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x1030
movq %rax, 0x18(%rbx)
leaq 0x5535(%rip), %rax      # 0x9160
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x3c57
movq (%rbx,%rcx,8), %rdx
xorl %esi, %esi
cmpq $0x4, %rsi
je 0x3c4e
movsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0x3c39
incq %rcx
addq $0x20, %rax
jmp 0x3c2d
leaq 0x54aa(%rip), %rdi      # 0x9108
leaq -0x18(%rbp), %rsi
callq 0x44a2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x553a(%rip), %rax      # 0x9230
movl (%rax), %edx
leaq 0x2661(%rip), %rsi      # 0x6360
leaq -0x32(%rbp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
leaq 0x2655(%rip), %rsi      # 0x6369
movq %rbx, %rdi
callq 0x1110
movq %rax, %rbx
leaq 0x5502(%rip), %rax      # 0x9228
movl (%rax), %edx
leaq 0x54fd(%rip), %r13      # 0x922c
movl (%r13), %ecx
leaq 0x2632(%rip), %rsi      # 0x636c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1120
leaq 0x54cd(%rip), %r15      # 0x9218
leaq 0x2624(%rip), %r14      # 0x6376
xorl %r12d, %r12d
leaq 0x54cc(%rip), %rax      # 0x9228
movslq (%rax), %rax
movslq (%r13), %rcx
imulq %rax, %rcx
cmpq %rcx, %r12
jge 0x3d85
movq (%r15), %rax
movl (%rax,%r12,4), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1120
incq %r12
jmp 0x3d55
leaq 0x54a4(%rip), %rax      # 0x9230
incl (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movsd 0x10(%rbp), %xmm0
movsd 0x18(%rbp), %xmm3
movsd 0x4956(%rip), %xmm1     # 0x9168
mulsd %xmm3, %xmm1
movsd 0x4942(%rip), %xmm4     # 0x9160
mulsd %xmm0, %xmm4
addsd %xmm1, %xmm4
movsd 0x20(%rbp), %xmm2
movsd 0x493d(%rip), %xmm1     # 0x9170
mulsd %xmm2, %xmm1
addsd %xmm4, %xmm1
addsd 0x4935(%rip), %xmm1     # 0x9178
movsd 0x493d(%rip), %xmm4     # 0x9188
mulsd %xmm3, %xmm4
movsd 0x4929(%rip), %xmm5     # 0x9180
mulsd %xmm0, %xmm5
addsd %xmm4, %xmm5
movsd 0x4929(%rip), %xmm4     # 0x9190
mulsd %xmm2, %xmm4
addsd %xmm5, %xmm4
addsd 0x4921(%rip), %xmm4     # 0x9198
movsd 0x4929(%rip), %xmm5     # 0x91a8
mulsd %xmm3, %xmm5
movsd 0x4915(%rip), %xmm6     # 0x91a0
mulsd %xmm0, %xmm6
addsd %xmm5, %xmm6
movsd 0x4915(%rip), %xmm5     # 0x91b0
mulsd %xmm2, %xmm5
addsd %xmm6, %xmm5
addsd 0x490d(%rip), %xmm5     # 0x91b8
mulsd 0x4915(%rip), %xmm3     # 0x91c8
mulsd 0x4905(%rip), %xmm0     # 0x91c0
mulsd 0x490d(%rip), %xmm2     # 0x91d0
addsd %xmm3, %xmm0
addsd %xmm0, %xmm2
addsd 0x4905(%rip), %xmm2     # 0x91d8
movq %rdi, %rax
divsd %xmm2, %xmm1
divsd %xmm2, %xmm4
divsd %xmm2, %xmm5
movsd %xmm1, (%rdi)
movsd %xmm4, 0x8(%rdi)
movsd %xmm5, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %eax, %eax
cmpq $0x4, %rax
je 0x4970
movq %rax, %rcx
shlq $0x5, %rcx
addq %rdx, %rcx
movq %rsi, %r8
xorl %r9d, %r9d
cmpq $0x4, %r9
je 0x4967
leaq (%rcx,%r9,8), %r10
andq $0x0, (%r10)
xorpd %xmm0, %xmm0
xorl %r11d, %r11d
cmpq $0x20, %r11
je 0x495e
movsd (%rdi,%r11), %xmm1
mulsd (%r8,%r11,4), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%r10)
addq $0x8, %r11
jmp 0x493d
incq %r9
addq $0x8, %r8
jmp 0x4928
incq %rax
addq $0x20, %rdi
jmp 0x4912
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
testl %edi, %edi
jle 0x49ba
testl %esi, %esi
jle 0x49ba
movl 0x48a8(%rip), %eax      # 0x9228
cmpl %edi, %eax
jl 0x49ba
cmpl %esi, 0x48a2(%rip)      # 0x922c
jl 0x49ba
pushq %rbp
movq %rsp, %rbp
decl %esi
imull %esi, %eax
movq 0x4884(%rip), %rcx      # 0x9220
addl %edi, %eax
decl %eax
cltq
ucomisd (%rcx,%rax,8), %xmm0
jb 0x49b9
movq 0x4868(%rip), %rdx      # 0x9218
andl $0x0, (%rdx,%rax,4)
movsd %xmm0, (%rcx,%rax,8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
testl %edi, %edi
jle 0x4a06
testl %esi, %esi
jle 0x4a06
movl 0x485f(%rip), %eax      # 0x9228
cmpl %edi, %eax
jl 0x4a06
cmpl %esi, 0x4859(%rip)      # 0x922c
jl 0x4a06
pushq %rbp
movq %rsp, %rbp
decl %esi
imull %esi, %eax
movq 0x483b(%rip), %rcx      # 0x9220
addl %edi, %eax
decl %eax
cltq
ucomisd (%rcx,%rax,8), %xmm0
jb 0x4a05
movq 0x481f(%rip), %rdx      # 0x9218
movl $0x1, (%rdx,%rax,4)
movsd %xmm0, (%rcx,%rax,8)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x9
popq %rbp
xorl %r14d, %r14d
movq 0x883f(%rip), %r15      # 0xafd8
leaq 0x48e5(%rip), %r12      # 0x7085
movl %r14d, %eax
xorl %edx, %edx
pushq $0xa
popq %rcx
divl %ecx
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
jbe 0x27f1
imull $0xa, %eax, %r13d
addl %ebp, %r13d
movsd (%rcx,%r14,8), %xmm0
movq %r15, %rdi
callq 0x2200
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
testl %r13d, %r13d
jne 0x27ea
movq %r15, %rdi
callq 0x20a0
incq %r14
decl %ebp
jmp 0x27a0
movq 0x87e0(%rip), %rdi      # 0xafd8
leaq 0x4888(%rip), %rsi      # 0x7087
callq 0x2150
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpl $0x2, %edi
jl 0x3035
pushq %rax
movq 0x8(%rsi), %rsi
leaq 0x816d(%rip), %rdi      # 0xb188
callq 0x2280
callq 0x283b
leaq 0x390c4(%rip), %rdi     # 0x3c0f0
callq 0x335c
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x6655(%rip), %r8d      # 0xb164
movslq %edx, %rax
movq 0x18(%rdi), %r9
imulq $0x18, %rax, %rax
addq %r9, %rax
movslq %esi, %rdx
imulq $0x18, %rdx, %rdx
addq %r9, %rdx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
xorl %esi, %esi
addq (%rdi), %rcx
testl %r8d, %r8d
cmovgl %r8d, %esi
cmpb $0x0, 0x661f(%rip)      # 0xb160
je 0x4b7e
xorpd %xmm0, %xmm0
xorl %edi, %edi
movapd 0x24ff(%rip), %xmm1     # 0x7050
cmpq %rdi, %rsi
je 0x4bb1
movq (%rax), %r8
movsd (%r8,%rdi,8), %xmm2
movq (%rdx), %r8
subsd (%r8,%rdi,8), %xmm2
movq (%rcx), %r8
subsd (%r8,%rdi,8), %xmm2
andpd %xmm1, %xmm2
subsd %xmm2, %xmm0
incq %rdi
jmp 0x4b51
xorpd %xmm0, %xmm0
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x4bb1
movq (%rax), %r8
movsd (%r8,%rdi,8), %xmm1
movq (%rdx), %r8
subsd (%r8,%rdi,8), %xmm1
movq (%rcx), %r8
subsd (%r8,%rdi,8), %xmm1
mulsd %xmm1, %xmm1
subsd %xmm1, %xmm0
incq %rdi
jmp 0x4b84
retq
// File: /workspace/github_cpp_makefile_star2_O2/shreyas-gopalakrishna[P]Concurrent-Skip-list/unit_test_3.cpp
// Function: skiplist_combined_operations()
void skiplist_combined_operations(){

    int start = (rand() % static_cast<int>(numbers_insert.size() + 1));
    int end = start + (rand() % static_cast<int>(numbers_insert.size() - start + 1));
    // cout << "Add Index: " << start << " " << end << endl;
    skiplist_add(start, end);

    start = (rand() % static_cast<int>(numbers_delete.size() + 1));
    end = start + (rand() % static_cast<int>(numbers_delete.size() - start + 1));
    // cout << "Remove Index: " << start << " " << end << endl;
    skiplist_remove(start, end);

    start = (rand() % static_cast<int>(numbers_get.size() + 1));
    end = start + (rand() % static_cast<int>(numbers_get.size() - start + 1));
    // cout << "Searching Index: " << start << " " << end << endl;
    skiplist_search(start, end);

    start = (rand() % static_cast<int>(numbers_insert.size() + 1));
    end = start + (rand() % static_cast<int>(numbers_insert.size() - start + 1));
    // cout << "Range: " << start << " " << end << endl;
    skiplist_range(start, end);
}

// Assembly:
pushq %rbx
callq 0x2050
movq 0x69ca(%rip), %rcx      # 0x91b8
subq 0x69bb(%rip), %rcx      # 0x91b0
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2050
movq 0x69ac(%rip), %rcx      # 0x91b8
subq 0x699d(%rip), %rcx      # 0x91b0
shrq $0x2, %rcx
movslq %ebx, %rdi
subl %edi, %ecx
incl %ecx
cltd
idivl %ecx
addl %edi, %edx
movslq %edx, %rsi
callq 0x262b
callq 0x2050
movq 0x6999(%rip), %rcx      # 0x91d0
subq 0x698a(%rip), %rcx      # 0x91c8
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2050
movq 0x697b(%rip), %rcx      # 0x91d0
subq 0x696c(%rip), %rcx      # 0x91c8
shrq $0x2, %rcx
movslq %ebx, %rdi
subl %edi, %ecx
incl %ecx
cltd
idivl %ecx
addl %edi, %edx
movslq %edx, %rsi
callq 0x26e4
callq 0x2050
movq 0x6968(%rip), %rcx      # 0x91e8
subq 0x6959(%rip), %rcx      # 0x91e0
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2050
movq 0x694a(%rip), %rcx      # 0x91e8
subq 0x693b(%rip), %rcx      # 0x91e0
shrq $0x2, %rcx
movslq %ebx, %rdi
subl %edi, %ecx
incl %ecx
cltd
idivl %ecx
addl %edi, %edx
movslq %edx, %rsi
callq 0x2745
callq 0x2050
movq 0x68ef(%rip), %rcx      # 0x91b8
subq 0x68e0(%rip), %rcx      # 0x91b0
shrq $0x2, %rcx
incl %ecx
cltd
idivl %ecx
movl %edx, %ebx
callq 0x2050
movq 0x68d1(%rip), %rcx      # 0x91b8
subq 0x68c2(%rip), %rcx      # 0x91b0
shrq $0x2, %rcx
subl %ebx, %ecx
incl %ecx
cltd
idivl %ecx
leal (%rdx,%rbx), %esi
movl %ebx, %edi
popq %rbx
jmp 0x27b8
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x3650(%rip), %r14      # 0x5fa8
pushq $0x1
popq %r12
leaq -0x78(%rbp), %rbx
leaq -0x60(%rbp), %r15
movl $0xa, -0x3c(%rbp)
andl $0x0, -0x30(%rbp)
leaq -0x3c(%rbp), %rdi
movl %r12d, %esi
movq 0x364b(%rip), %r13      # 0x5fc8
movq %r13, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x2080
movq %rbx, (%rsp)
leaq -0x30(%rbp), %rdi
movl %r12d, %esi
movq %r13, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x2110
movl -0x30(%rbp), %r13d
testl %r13d, %r13d
je 0x2a11
pushq $-0x1
popq %rax
cmovnsl %r13d, %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, -0x38(%rbp)
movq %rbx, (%rsp)
movq %rax, %rdi
movl %r13d, %esi
movq 0x35c3(%rip), %rdx      # 0x5f98
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x2110
movq -0x38(%rbp), %rsi
movq %r15, %rdi
leaq -0x29(%rbp), %rdx
callq 0x20a0
movq -0x60(%rbp), %rdi
callq 0x2120
movq %r15, %rdi
callq 0x20c0
leaq -0x38(%rbp), %rdi
callq 0x2dc6
jmp 0x2964
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a22
movq %rax, %rbx
jmp 0x2a33
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20c0
leaq -0x38(%rbp), %rdi
callq 0x2dc6
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/kaityo256[P]cps/cps.cpp
// Function: loadfile(int, char**)
int loadfile(int argc, char **argv) {
  int rank, procs;
  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  MPI_Comm_size(MPI_COMM_WORLD, &procs);
  if (rank != 0) {
    return 1;
  }
  if (argc < 2) {
    std::cout << "Usage: cps commandlist" << std::endl;
    return 0;
  }
  std::string filename = argv[1];
  std::ifstream ifs(filename);
  if (ifs.fail()) {
    std::cerr << "Could not open " << filename << std::endl;
    return 0;
  }
  std::string line;
  while (getline(ifs, line)) {
    if (line.length() > 0 && line[0] == '#') {
      continue;
    }
    command_list.push_back(line);
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rsi, %rbx
movl %edi, %r14d
movq 0x3545(%rip), %r15      # 0x5fa8
leaq -0x28(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x21e0
leaq -0x24(%rbp), %rsi
movq %r15, %rdi
callq 0x2190
cmpl $0x0, (%r12)
je 0x2a8d
pushq $0x1
popq %rbx
jmp 0x2b97
cmpl $0x1, %r14d
jg 0x2ab5
movq 0x3526(%rip), %rdi      # 0x5fc0
leaq 0x1615(%rip), %rsi      # 0x40b6
callq 0x2160
movq %rax, %rdi
callq 0x20d0
xorl %ebx, %ebx
jmp 0x2b97
movq 0x8(%rbx), %rsi
leaq -0x68(%rbp), %rbx
leaq -0x270(%rbp), %rdx
movq %rbx, %rdi
callq 0x20a0
leaq -0x270(%rbp), %rdi
pushq $0x8
popq %rdx
movq %rbx, %rsi
callq 0x2240
movq -0x270(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x250(%rbp,%rax)
je 0x2b1e
movq 0x34f6(%rip), %rdi      # 0x5ff0
leaq 0x15cc(%rip), %rsi      # 0x40cd
callq 0x2160
leaq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x2140
xorl %ebx, %ebx
movq %rax, %rdi
callq 0x20d0
jmp 0x2b82
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x270(%rbp), %rbx
leaq -0x48(%rbp), %r14
leaq 0x3638(%rip), %r15      # 0x6178
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2050
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2b76
cmpq $0x0, -0x40(%rbp)
je 0x2b69
movq -0x48(%rbp), %rax
cmpb $0x23, (%rax)
je 0x2b40
movq %r15, %rdi
movq %r14, %rsi
callq 0x2dea
jmp 0x2b40
leaq -0x48(%rbp), %rdi
callq 0x20c0
pushq $0x1
popq %rbx
leaq -0x270(%rbp), %rdi
callq 0x2060
leaq -0x68(%rbp), %rdi
callq 0x20c0
movl %ebx, %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2bcb
movq %rax, %rbx
jmp 0x2bbf
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20c0
leaq -0x270(%rbp), %rdi
callq 0x2060
leaq -0x68(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x2c(%rbp), %rbx
movl %edi, (%rbx)
leaq -0x20(%rbp), %rax
movq %rsi, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21f0
movq 0x33a2(%rip), %r14      # 0x5fa8
leaq -0x18(%rbp), %rsi
movq %r14, %rdi
callq 0x21e0
leaq -0x14(%rbp), %rsi
movq %r14, %rdi
callq 0x2190
movl (%rbx), %edi
cmpl $0x2, %edi
jl 0x2c73
cmpl $0x1, -0x14(%rbp)
jle 0x2c73
movq -0x20(%rbp), %rsi
callq 0x2a44
leaq -0x28(%rbp), %rdi
movl %eax, (%rdi)
leaq -0x24(%rbp), %rbx
andl $0x0, (%rbx)
movq 0x3380(%rip), %rcx      # 0x5fc8
movq 0x3361(%rip), %r8       # 0x5fb0
movq 0x3352(%rip), %r9       # 0x5fa8
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x21a0
cmpl $0x0, (%rbx)
je 0x2c8b
cmpl $0x0, -0x18(%rbp)
je 0x2c83
callq 0x2940
jmp 0x2c8b
cmpl $0x0, -0x18(%rbp)
je 0x2c9b
callq 0x20f0
pushq $0x1
popq %rax
jmp 0x2c92
movl -0x14(%rbp), %edi
callq 0x24ab
callq 0x20f0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x332e(%rip), %r14      # 0x5fd0
movq (%r14), %rcx
leaq 0x1431(%rip), %rdi      # 0x40dd
pushq $0x2b
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2290
movq (%r14), %rcx
leaq 0x1445(%rip), %rdi      # 0x4109
pushq $0x1d
popq %rsi
movq %rbx, %rdx
callq 0x2290
jmp 0x2c79
nop
// File: /workspace/github_cpp_makefile_star2_O2/king1600[P]cordpp/src/base64.cc
// Function: cordpp::b64_encode(char const*, unsigned long)
char* cordpp::b64_encode(const char *src, const size_t length) {
  // (length * 4 / 3) rounded up to nearest multiple of 4
  const size_t encoded_length = ((length<<2)/3+3)&-4;
  char *buffer = new char[encoded_length + 1];

  // perform base64 calculation
  size_t i;
  char *p = buffer;
  for(i = 0; i < length-2; i += 3) {
      *p++ = B64_CHARSET[(src[i] >> 2) & 0x3F];
      *p++ = B64_CHARSET[((uint8_t)src[i] << 4 | (uint8_t)src[i+1] >> 4) & 0x3F];
      *p++ = B64_CHARSET[((uint8_t)src[i+1] << 2 | (uint8_t)src[i+2] >> 6) & 0x3F];
      *p++ = B64_CHARSET[(uint8_t)src[i+2] & 0x3F];
  }

  // this returns 3 instead of 0 if we need no padding but
  // if we need no padding we dont need to do anything
  int padding = (length % 3)^3;
  if (padding == 1) {
      *p++ = B64_CHARSET[(src[i] >> 2) & 0x3F];
      *p++ = B64_CHARSET[(src[i] << 4 | src[i+1] >> 4) & 0x3F];
      *p++ = B64_CHARSET[(src[i+1] << 2) & 0x3F];
      *p++ = '=';
  } else if (padding == 2) {
      *p++ = B64_CHARSET[(src[i] >> 2) & 0x3F];
      *p++ = B64_CHARSET[(src[i] << 4) & 0x3F];
      *p++ = '=';
      *p++ = '=';
  }

  // add null terminator and return constructed buffer
  *p = '\0';
  return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq (,%rsi,4), %rax
xorl %r15d, %r15d
pushq $0x3
popq %r12
xorl %edx, %edx
divq %r12
addq $0x3, %rax
movabsq $0x7ffffffffffffffc, %rdi # imm = 0x7FFFFFFFFFFFFFFC
andq %rax, %rdi
incq %rdi
callq 0xa480
movq %rax, %rcx
leaq -0x2(%r14), %rax
leaq 0x251fb(%rip), %rdi     # 0x31010
movq %rcx, %rsi
cmpq %rax, %r15
jae 0xbe7c
movzbl (%rbx,%r15), %edx
movl %edx, %r8d
shrl $0x2, %r8d
movb (%r8,%rdi), %r8b
movb %r8b, (%rsi)
shll $0x4, %edx
movzbl 0x1(%rbx,%r15), %r8d
movl %r8d, %r9d
shrl $0x4, %r9d
andl $0x30, %edx
orl %r9d, %edx
movb (%rdx,%rdi), %dl
movb %dl, 0x1(%rsi)
movzbl 0x2(%rbx,%r15), %edx
movl %edx, %r9d
shrl $0x6, %r9d
andl $0xf, %r8d
leal (%r9,%r8,4), %r8d
movb (%r8,%rdi), %r8b
movb %r8b, 0x2(%rsi)
andl $0x3f, %edx
movb (%rdx,%rdi), %dl
movb %dl, 0x3(%rsi)
addq $0x4, %rsi
addq $0x3, %r15
jmp 0xbe18
movq %r14, %rax
xorl %edx, %edx
divq %r12
cmpq $0x1, %rdx
je 0xbecc
cmpq $0x2, %rdx
jne 0xbef3
movzbl (%rbx,%r15), %eax
movl %eax, %edx
shrl $0x2, %edx
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
shll $0x4, %eax
movzbl 0x1(%rbx,%r15), %edx
movl %edx, %r8d
sarb $0x4, %r8b
movzbl %r8b, %r8d
orl %eax, %r8d
andl $0x3f, %r8d
movb (%r8,%rdi), %al
movb %al, 0x1(%rsi)
andl $0xf, %edx
movb (%rdi,%rdx,4), %al
movb %al, 0x2(%rsi)
jmp 0xbeeb
movzbl (%rbx,%r15), %eax
movl %eax, %edx
shrl $0x2, %edx
movb (%rdx,%rdi), %dl
movb %dl, (%rsi)
shll $0x4, %eax
andl $0x30, %eax
movb (%rax,%rdi), %al
movb %al, 0x1(%rsi)
movb $0x3d, 0x2(%rsi)
movb $0x3d, 0x3(%rsi)
addq $0x4, %rsi
movb $0x0, (%rsi)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/king1600[P]cordpp/src/base64.cc
// Function: cordpp::b64_decode(char const*)
char* cordpp::b64_decode(const char *src) {
  // The input is invalid or not properly padded
  const size_t src_len = std::strlen(src);
  if (src_len % 4 != 0)
    return nullptr;

  // instead of figuring out exactly how long the decoded string should be
  // allocate enough. at most this is an extra 2 bytes
  char *buffer = new char[(src_len * 3 >> 2) + 1];

  // decode content with lookup table
  size_t i;
  char *p = buffer;
  for(i = 0; i < src_len - 4; i += 4) {
    *p++ = (B64_LOOKUP[(uint8_t)src[i]] << 2 | B64_LOOKUP[(uint8_t)src[i+1]] >> 4) & 0xff;
    *p++ = (B64_LOOKUP[(uint8_t)src[i+1]] << 4 | B64_LOOKUP[(uint8_t)src[i+2]] >> 2) & 0xff;
    *p++ = (B64_LOOKUP[(uint8_t)src[i+2]] << 6 | B64_LOOKUP[(uint8_t)src[i+3]]) & 0xff;
  }

  // decode padding
  *p++ = (B64_LOOKUP[(uint8_t)src[i]] << 2 | B64_LOOKUP[(uint8_t)src[i+1]] >> 4) & 0xff;

  // decode rest of padding
  if (src[i+2] != '=') {
    *p++ = (B64_LOOKUP[(uint8_t)src[i+1]] << 4 | B64_LOOKUP[(uint8_t)src[i+2]] >> 2) & 0xff;
    if (src[i+3] != '=')
      *p++ = (B64_LOOKUP[(uint8_t)src[i+2]] << 6 | B64_LOOKUP[(uint8_t)src[i+3]]) & 0xff;
    else
      *p++ = B64_LOOKUP[(uint8_t)src[i+2]] << 6 & 0xff;
  } else {
    *p++ = B64_LOOKUP[(uint8_t)src[i+1]] << 4 & 0xff;
  }

  // add null terminator and return constructed buffer
  *p = '\0';
  return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xa3f0
movq %rax, %r14
testb $0x3, %r14b
je 0xbf21
xorl %eax, %eax
jmp 0xbfe7
leaq (%r14,%r14,2), %rdi
shrq $0x2, %rdi
incq %rdi
callq 0xa480
addq $-0x4, %r14
movq %rax, %rcx
addq $0x2, %rcx
xorl %esi, %esi
leaq 0x2511b(%rip), %rdx     # 0x31060
movzbl (%rbx,%rsi), %edi
movb (%rdi,%rdx), %r8b
shlb $0x2, %r8b
movzbl 0x1(%rbx,%rsi), %edi
movb (%rdi,%rdx), %dil
movl %edi, %r9d
shrb $0x4, %r9b
orb %r8b, %r9b
movb %r9b, -0x2(%rcx)
cmpq %r14, %rsi
jae 0xbfa3
shlb $0x4, %dil
movzbl 0x2(%rbx,%rsi), %r8d
movb (%r8,%rdx), %r8b
movl %r8d, %r9d
shrb $0x2, %r9b
orb %dil, %r9b
movb %r9b, -0x1(%rcx)
shlb $0x6, %r8b
movzbl 0x3(%rbx,%rsi), %edi
orb (%rdi,%rdx), %r8b
movb %r8b, (%rcx)
addq $0x4, %rsi
addq $0x3, %rcx
jmp 0xbf45
movzbl 0x2(%rbx,%rsi), %r8d
shlb $0x4, %dil
cmpq $0x3d, %r8
jne 0xbfb9
movb %dil, -0x1(%rcx)
jmp 0xbfe4
movb (%r8,%rdx), %r8b
movl %r8d, %r9d
shrb $0x2, %r9b
orb %dil, %r9b
movb %r9b, -0x1(%rcx)
movzbl 0x3(%rbx,%rsi), %esi
shlb $0x6, %r8b
cmpq $0x3d, %rsi
je 0xbfde
orb (%rsi,%rdx), %r8b
movb %r8b, (%rcx)
incq %rcx
movb $0x0, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
andq $0x0, (%rdi)
andq $0x0, 0x18(%rdi)
movq $0xa, 0x10(%rdi)
movq $0x3, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movl $0xf0, %edi
callq 0xa480
movq %rax, 0x30(%rbx)
pushq $0xa
popq %rcx
xorl %eax, %eax
movq %rax, 0x8(%rbx)
cmpq %rcx, %rax
jae 0xc267
movq 0x30(%rbx), %rcx
imulq $0x18, %rax, %rdx
andq $0x0, (%rcx,%rdx)
movq %rax, 0x8(%rcx,%rdx)
andq $0x0, 0x10(%rcx,%rdx)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
incq %rax
jmp 0xc239
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xc30b
movq %rsi, %r14
pushq $0x18
popq %rcx
movq %rsi, %rax
mulq %rcx
pushq $-0x1
popq %rdi
cmovnoq %rax, %rdi
callq 0xa480
movq %rax, %r15
leaq 0x10(%rbx), %r12
movq 0x10(%rbx), %rax
movq 0x30(%rbx), %rdi
movq %r15, %rcx
addq $0x10, %rcx
imulq $0x18, %rax, %rdx
addq %rdi, %rdx
addq $0x10, %rdx
xorl %esi, %esi
movq %rsi, 0x8(%rbx)
cmpq %rsi, %r14
je 0xc2f9
movl $0x0, %r8d
movq %rsi, %r9
movl $0x0, %r10d
cmpq %rax, %rsi
ja 0xc2e1
movq -0x10(%rdx), %r10
movq -0x8(%rdx), %r9
movq (%rdx), %r8
movq %r10, -0x10(%rcx)
movq %r9, -0x8(%rcx)
movq %r8, (%rcx)
incq %rsi
addq $0x18, %rcx
addq $-0x18, %rdx
jmp 0xc2b9
movq %r14, 0x10(%rbx)
pushq $0x18
popq %rsi
callq 0xa110
movq %r15, 0x30(%rbx)
jmp 0xc312
addq $0x10, %rbx
movq %rbx, %r12
movq (%r12), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, (%rdi)
xorl %eax, %eax
pushq $0x30
popq %r14
movq %rax, 0x8(%rbx)
cmpq 0x10(%rbx), %rax
jae 0xc426
movq 0x30(%rbx), %rcx
imulq $0x18, %rax, %rdx
movq (%rcx,%rdx), %r15
testq %r15, %r15
je 0xc421
leaq 0x10(%r15), %rdi
callq 0xac38
movq %r15, %rdi
movq %r14, %rsi
callq 0xa110
movq 0x8(%rbx), %rax
movq 0x30(%rbx), %rcx
imulq $0x18, %rax, %rdx
andq $0x0, 0x10(%rcx,%rdx)
incq %rax
jmp 0xc3e0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x50(%rdi), %r14
movq %r14, %rdi
callq 0xab50
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x1d778
movq 0x8(%rbx), %r14
leaq 0x24cce(%rip), %rsi     # 0x311dc
leaq 0x40(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xc152
leaq 0x28399(%rip), %rsi     # 0x348bd
leaq 0x20(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xc152
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xc894
leaq 0x60(%rsp), %r8
andq $0x0, 0x8(%r8)
movq %rbx, (%r8)
leaq 0xb8(%rip), %rax        # 0xc60e
movq %rax, 0x18(%r8)
leaq 0x1ab(%rip), %rax       # 0xc70c
movq %rax, 0x10(%r8)
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rcx
callq 0x1d782
leaq 0x60(%rsp), %rdi
callq 0xe8c8
leaq 0x10(%rsp), %rdi
callq 0xc8b0
leaq 0x20(%rsp), %rdi
callq 0xac38
leaq 0x40(%rsp), %rdi
callq 0xac38
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x20b9a
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xe8c8
leaq 0x10(%rsp), %rdi
callq 0xc8b0
leaq 0x20(%rsp), %rdi
callq 0xac38
jmp 0xc5e1
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xac38
movq %rbx, %rdi
callq 0xa6c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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> const& 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[]<char const>(char const*) const
const_reference operator[](T* key) const
    {
        // at only works for objects
        if (JSON_LIKELY(is_object()))
        {
            assert(m_value.object->find(key) != m_value.object->end());
            return m_value.object->find(key)->second;
        }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xef04
movq %rsi, %rbx
movq 0x8(%r14), %r15
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0xc152
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xf1ba
movq 0x8(%r14), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0xef6c
leaq 0x8(%rsp), %rdi
callq 0xac38
movq 0x8(%r14), %r14
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
callq 0xc152
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xf1ba
movq %rax, %rbx
addq $0x40, %rbx
leaq 0x8(%rsp), %rdi
callq 0xac38
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0xa3c0
movq %rax, %rbx
movq %r14, %rdi
callq 0xf17a
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0xc152
leaq 0x2277b(%rip), %rsi     # 0x316ab
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0xf155
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
callq 0xf0a0
xorl %ebp, %ebp
leaq 0x40703(%rip), %rsi     # 0x4f660
leaq 0x236(%rip), %rdx       # 0xf19a
movq %rbx, %rdi
callq 0xa690
leaq 0x225a9(%rip), %rdi     # 0x3151c
leaq 0x223be(%rip), %rsi     # 0x31338
leaq 0x225ce(%rip), %rcx     # 0x3154f
movl $0x27a7, %edx           # imm = 0x27A7
callq 0xa1a0
jmp 0xef8f
jmp 0xef9e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xac38
jmp 0xefd4
movq %rax, %r14
jmp 0xefd4
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xac38
jmp 0xefb8
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0xac38
testb %bpl, %bpl
jne 0xefcc
jmp 0xefd4
movq %rax, %r14
movq %rbx, %rdi
callq 0xa8d0
movq %r14, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movups %xmm0, 0x6e(%r14)
movaps %xmm0, 0x60(%r14)
movaps %xmm0, 0x50(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
leaq 0x2268e(%rip), %rdx     # 0x31c08
pushq $0x7e
popq %rsi
movq %r14, %rdi
callq 0xa8e0
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc152
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rcx, (%rdi)
movq %r8, 0x8(%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rdx, %r14
movq %rsi, %r13
xorl %eax, %eax
movb %al, 0x20(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
leaq 0x10(%rdi), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x30(%rdi), %r15
movb %al, 0x60(%rdi)
leaq 0x18(%rsi), %rbp
movq %rbp, %rdi
callq 0x20baa
leaq 0x70(%rbx), %r12
movq %r12, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x14e2e
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xab50
movq %r13, 0xe8(%rbx)
andl $0x0, 0x4c(%rbx)
movb $0x0, 0x38(%rbx)
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x1244d
leaq 0x10(%rsp), %r14
movq (%r14), %rsi
andq $0x0, (%r14)
movq %r15, %rdi
callq 0x1294e
movq %r14, %rdi
callq 0xe7fc
movq %rbx, %rdi
callq 0xfcee
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xfcb7
movq %rax, %r14
movq %r12, %rdi
callq 0xce80
jmp 0xfcc7
movq %rax, %r14
addq $0x50, %rbx
movq %rbx, %rdi
callq 0xac38
movq %r15, %rdi
callq 0xe7fc
movq 0x8(%rsp), %rdi
callq 0xac38
movq %r14, %rdi
callq 0xa6c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/king1600[P]cordpp/./include/json.h
// Function: void 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>>::dump_integer<long, 0>(long)
void dump_integer(NumberType x)
    {
        // special case for "0"
        if (x == 0)
        {
            o->write_character('0');
            return;
        }

        const bool is_negative = x < 0;
        std::size_t i = 0;

        // spare 1 byte for '\0'
        while (x != 0 and i < number_buffer.size() - 1)
        {
            const auto digit = std::labs(static_cast<long>(x % 10));
            number_buffer[i++] = static_cast<char>('0' + digit);
            x /= 10;
        }

        // make sure the number has been processed completely
        assert(x == 0);

        if (is_negative)
        {
            // make sure there is capacity for the '-'
            assert(i < number_buffer.size() - 2);
            number_buffer[i++] = '-';
        }

        std::reverse(number_buffer.begin(), number_buffer.begin() + i);
        o->write_characters(number_buffer.data(), i);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x14457
leaq 0x10(%rbx), %r14
xorl %r15d, %r15d
pushq $0xa
popq %rcx
movq %rsi, %rax
testq %rax, %rax
je 0x14420
cmpq $0x3f, %r15
je 0x1446a
cqto
idivq %rcx
movq %rdx, %rdi
negq %rdi
cmovsq %rdx, %rdi
addb $0x30, %dil
movb %dil, 0x10(%rbx,%r15)
incq %r15
jmp 0x143f8
testq %rsi, %rsi
jns 0x14434
cmpq $0x3e, %r15
jae 0x14489
movb $0x2d, 0x10(%rbx,%r15)
incq %r15
leaq (%r14,%r15), %rsi
movq %r14, %rdi
callq 0x149b6
movq (%rbx), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq (%rbx), %rdi
movq (%rdi), %rax
movq (%rax), %rax
pushq $0x30
popq %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
leaq 0x1e632(%rip), %rdi     # 0x32aa3
leaq 0x1cec0(%rip), %rsi     # 0x31338
leaq 0x1e62b(%rip), %rcx     # 0x32aaa
movl $0x19b2, %edx           # imm = 0x19B2
callq 0xa1a0
leaq 0x1e6aa(%rip), %rdi     # 0x32b3a
leaq 0x1cea1(%rip), %rsi     # 0x31338
leaq 0x1e60c(%rip), %rcx     # 0x32aaa
movl $0x19b7, %edx           # imm = 0x19B7
callq 0xa1a0
// File: /workspace/github_cpp_makefile_star2_O2/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:
testb %dil, %dil
js 0x1479c
xorl %eax, %eax
retq
movl %edi, %eax
andb $-0x20, %al
cmpb $-0x40, %al
jne 0x147a8
pushq $0x1
jmp 0x147b2
movl %edi, %eax
andb $-0x10, %al
cmpb $-0x20, %al
jne 0x147b4
pushq $0x2
popq %rax
retq
andb $-0x8, %dil
xorl %eax, %eax
cmpb $-0x10, %dil
sete %al
leaq -0x1(,%rax,4), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0x19145
movq 0x8(%r14), %rax
shlq $0x4, %rsi
addq (%rax), %rsi
movq %rsi, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0xa3c0
movq %rax, %rbx
movq %r14, %rdi
callq 0xf17a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0xc152
leaq 0x1853a(%rip), %rsi     # 0x316ab
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xf155
movb $0x1, %bpl
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
callq 0xf0a0
xorl %ebp, %ebp
leaq 0x364c2(%rip), %rsi     # 0x4f660
leaq -0xa00b(%rip), %rdx     # 0xf19a
movq %rbx, %rdi
callq 0xa690
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0xac38
jmp 0x191c2
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0xac38
testb %bpl, %bpl
jne 0x191d6
jmp 0x191de
movq %rax, %r14
movq %rbx, %rdi
callq 0xa8d0
movq %r14, %rdi
callq 0xa6c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1a09e
cmpb $0x1, (%r15)
jne 0x1a08b
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0xf1ba
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x40(%rdi), %rax
leaq 0x1(%rax), %rdx
movq 0x28(%rdi), %rcx
movq 0x38(%rdi), %rsi
subq %rcx, %rsi
cmpq %rsi, %rdx
ja 0x1b3b2
movq 0x30(%r14), %rdx
subq %rcx, %rdx
cmpq %rdx, %rax
jae 0x1b3d0
leaq 0x1(%rax), %rdx
movq %rdx, 0x40(%r14)
movb %bl, (%rcx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x28(%r14), %rdi
addq %rsi, %rsi
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
callq 0x1b546
movq 0x28(%r14), %rcx
movq 0x40(%r14), %rax
jmp 0x1b393
leaq 0x18073(%rip), %rdi     # 0x3344a
leaq 0x15f5a(%rip), %rsi     # 0x31338
leaq 0x1807b(%rip), %rcx     # 0x33460
movl $0xa3b, %edx            # imm = 0xA3B
callq 0xa1a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>>::get_token_string() const
std::string get_token_string() const
    {
        // get the raw byte sequence of the last token
        std::string s = ia->read(start_pos, chars_read - start_pos);

        // escape control characters
        std::string result;
        for (auto c : s)
        {
            if (c == '\0' or c == std::char_traits<char>::eof())
            {
                // ignore EOF
                continue;
            }
            else if ('\x00' <= c and c <= '\x1f')
            {
                // escape control characters
                std::stringstream ss;
                ss << "<U+" << std::setw(4) << std::uppercase << std::setfill('0')
                   << std::hex << static_cast<int>(c) << ">";
                result += ss.str();
            }
            else
            {
                // add character as is
                result.push_back(c);
            }
        }

        return result;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, %rbx
movq 0x20(%rsi), %rdx
movq (%rsi), %rax
movq 0x18(%rsi), %rcx
subq %rdx, %rcx
movq (%rax), %r8
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq *0x8(%r8)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%r14), %rbp
movq 0x8(%r14), %r14
xorl %r12d, %r12d
leaq 0x20(%rsp), %r15
cmpq %r12, %r14
je 0x1b92e
movsbl (%rbp,%r12), %r13d
leal 0x1(%r13), %eax
cmpb $0x2, %al
jb 0x1b926
cmpb $0x1f, %r13b
ja 0x1b91b
leaq 0x40(%rsp), %rdi
callq 0xa2f0
leaq 0x50(%rsp), %rdi
leaq 0x17fcd(%rip), %rsi     # 0x33861
callq 0xa5e0
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movq $0x4, 0x10(%rax,%rdx)
movq -0x18(%rcx), %rcx
orl $0x4000, 0x18(%rax,%rcx) # imm = 0x4000
movq %rax, %rdi
pushq $0x30
popq %rsi
callq 0xa780
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movl %r13d, %esi
callq 0xa320
movq %rax, %rdi
leaq 0x17002(%rip), %rsi     # 0x328ec
callq 0xa5e0
movq %r15, %rdi
leaq 0x58(%rsp), %rsi
callq 0xa3e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa8a0
movq %r15, %rdi
callq 0xac38
leaq 0x40(%rsp), %rdi
callq 0xa3b0
jmp 0x1b926
movq %rbx, %rdi
movl %r13d, %esi
callq 0xabb0
incq %r12
jmp 0x1b859
movq %rsp, %rdi
callq 0xac38
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1b94d
movq %rax, %r14
jmp 0x1b970
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xac38
jmp 0x1b966
jmp 0x1b963
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0xa3b0
movq %rbx, %rdi
callq 0xac38
movq %rsp, %rdi
callq 0xac38
movq %r14, %rdi
callq 0xa6c0