LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/cmaureir[P]strip-packing/scattersearch.cpp
// Function: is_in(solution, std::vector<solution, std::allocator<solution>>)
bool is_in(solution tmp, vector<solution> tmp_sols)
{
    bool all = true;
    for (int i = 0; i < (int)tmp_sols.size(); i++) {
        for (int j = 0; j < (int)tmp.items.size(); j++) {
            if(tmp.items[j] != tmp_sols[i].items[j]){
                all = false;
            }
            if(!all){
                break;
            }
        }
    }
    return all;
}

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
subq %rcx, %rax
sarq $0x5, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
testl %edx, %edx
jle 0x70fc
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdi
subq %rsi, %rdi
shrq $0x2, %rdi
movslq %edi, %r8
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movb $0x1, %al
xorl %r9d, %r9d
xorl %r10d, %r10d
testl %edi, %edi
jle 0x70ee
leaq (%r10,%r10,2), %r11
shlq $0x5, %r11
movq (%rcx,%r11), %r11
movl $0x1, %ebx
movl -0x4(%rsi,%rbx,4), %ebp
cmpl -0x4(%r11,%rbx,4), %ebp
movzbl %al, %eax
cmovnel %r9d, %eax
testb $0x1, %al
je 0x70ee
leaq 0x1(%rbx), %r14
cmpq %r8, %rbx
movq %r14, %rbx
jl 0x70ce
incq %r10
cmpq %rdx, %r10
jne 0x70b9
popq %rbx
popq %r14
popq %rbp
jmp 0x70fe
movb $0x1, %al
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/cmaureir[P]strip-packing/scattersearch.cpp
// Function: place_item(int, int, int, int, int, int**)
void place_item(int item, int item_w, int item_h, int a, int b, int **strip){
    //cout << "place_item()" << endl;
    for (int i = a; i < a + item_w; i++) {
        for (int j = b; j < b + item_h; j++) {
            strip[i][j] = item;
        }
    }
}

// Assembly:
testl %esi, %esi
jle 0x7233
pushq %rbx
addl %ecx, %esi
movslq %r8d, %r10
addl %edx, %r8d
movslq %r8d, %r8
movslq %ecx, %rax
movslq %esi, %rcx
leaq 0x1(%r10), %rsi
cmpq %r8, %rsi
cmovgq %rsi, %r8
subq %r10, %r8
leaq 0x3(%r8), %rsi
andq $-0x4, %rsi
decq %r8
movq %r8, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq 0xc(,%r10,4), %r8
movdqa 0x5f12(%rip), %xmm1     # 0xd060
movdqa 0x5f1a(%rip), %xmm2     # 0xd070
movdqa 0x5f22(%rip), %xmm3     # 0xd080
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
testl %edx, %edx
jle 0x7226
movq (%r9,%rax,8), %r10
addq %r8, %r10
xorl %r11d, %r11d
movq %r11, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %ebx
notl %ebx
testb $0x1, %bl
je 0x71bf
movl %edi, -0xc(%r10,%r11,4)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %ebx
testb $0x1, %bl
je 0x71d2
movl %edi, -0x8(%r10,%r11,4)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %ebx
testb $0x1, %bl
je 0x720b
movl %edi, -0x4(%r10,%r11,4)
pextrw $0x4, %xmm5, %ebx
testb $0x1, %bl
je 0x7219
movl %edi, (%r10,%r11,4)
addq $0x4, %r11
cmpq %r11, %rsi
jne 0x7178
incq %rax
cmpq %rcx, %rax
jl 0x7166
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/cmaureir[P]strip-packing/scattersearch.cpp
// Function: save_best_solution(std::vector<solution, std::allocator<solution>>)
void save_best_solution(vector<solution> tmp)
{
    //cout << "save_best_solution()" << endl;
    sort_solutions(tmp);
    best = tmp[0];
    fitness_calculation_one(best);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6eed
movq (%rbx), %rbx
leaq 0xa817(%rip), %r14      # 0x122f8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x53a2
leaq 0x18(%rbx), %rsi
leaq 0xa819(%rip), %rdi      # 0x12310
callq 0x53a2
leaq 0x30(%rbx), %rsi
leaq 0xa821(%rip), %rdi      # 0x12328
callq 0x53a2
movups 0x48(%rbx), %xmm0
movups %xmm0, 0xa829(%rip)     # 0x12340
movq 0x58(%rbx), %rax
movq %rax, 0xa82e(%rip)      # 0x12350
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7234
// File: /workspace/github_cpp_makefile_star2_O3/cmaureir[P]strip-packing/scattersearch.cpp
// Function: refset_modification(std::vector<solution, std::allocator<solution>>)
void refset_modification(vector<solution> tmp_sols)
{
    //cout << "refset_modification()" << endl;

    int i;
    vector<solution> tmp;

    // Adding «new_set» elements
    for (i = 0; i < b*(b-1)/2; i++) {
        tmp.push_back(tmp_sols[i]);
    }

    // Adding previous «refset» elements
    for (i = 0; i < b; i++) {
        tmp.push_back(refset[i]);
    }

    // Sorting «tmp» solutions
    sort_solutions(tmp);

    // Removing all «refset« values
    refset.clear();

    // Adding new «b» «refset» values
    for (i = 0; i < b; i++) {
        refset.push_back(tmp[i]);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
xorl %r15d, %r15d
movq (%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x8c66
addq $0x60, %r15
cmpq $0x10e0, %r15           # imm = 0x10E0
jne 0x82dc
xorl %r14d, %r14d
movq %rsp, %rbx
movq 0x9fac(%rip), %rsi      # 0x122b0
addq %r14, %rsi
movq %rbx, %rdi
callq 0x8c66
addq $0x60, %r14
cmpq $0x3c0, %r14            # imm = 0x3C0
jne 0x82fd
movq %rsp, %rdi
callq 0x6eed
movq 0x9f85(%rip), %rsi      # 0x122b0
leaq 0x9f7e(%rip), %rbx      # 0x122b0
movq %rbx, %rdi
callq 0xc2ea
xorl %r14d, %r14d
movq (%rsp), %rsi
addq %r14, %rsi
movq %rbx, %rdi
callq 0x8c66
addq $0x60, %r14
cmpq $0x3c0, %r14            # imm = 0x3C0
jne 0x833d
movq %rsp, %rdi
callq 0x4e5a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x8371
jmp 0x8371
jmp 0x8371
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4e5a
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O3/cmaureir[P]strip-packing/scattersearch.cpp
// Function: shift_left(solution)
solution shift_left(solution tmp)
{
    int n = (int)tmp.items.size();
    int value = tmp.items[0];
    for (int i = 0; i < n; i++) {
        tmp.items[i] = tmp.items[i+1];
    }
    tmp.items[n-1] = value;
    return tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
movq %r12, %r13
subq %r15, %r13
movq %r13, %rax
shrq $0x2, %rax
movl (%r15), %ebp
testl %eax, %eax
jle 0x83c9
leaq 0x4(%r15), %rsi
movabsq $0x1fffffffc, %rdx      # imm = 0x1FFFFFFFC
andq %r13, %rdx
movq %r15, %rdi
callq 0x43f0
shlq $0x1e, %r13
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %r13, %rax
sarq $0x1e, %rax
movl %ebp, (%r15,%rax)
movq %r15, (%rbx)
movq %r12, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movups 0x18(%r14), %xmm1
movups %xmm1, 0x18(%rbx)
movq 0x28(%r14), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x28(%r14)
movups %xmm0, 0x18(%r14)
movups 0x30(%r14), %xmm1
movups %xmm1, 0x30(%rbx)
movq 0x40(%r14), %rcx
movq %rcx, 0x40(%rbx)
movq %rax, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movq 0x58(%r14), %rax
movq %rax, 0x58(%rbx)
movups 0x48(%r14), %xmm0
movups %xmm0, 0x48(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cmaureir[P]strip-packing/scattersearch.cpp
// Function: refset_rebuild()
void refset_rebuild()
{
    //cout << "refset_rebuild()" << endl;
    // Removing the worst b/2 solutions
    sort_solutions(refset);
    refset.erase(refset.end()-(b/2), refset.end());

    // Generating «popsize» best random + local search
    vector<solution> new_sols;
    solutions_generation(new_sols);
    fitness_calculation(new_sols);
    new_sols = solutions_improvement2(new_sols);

    // Choosing the b/2 worst solutions
    sort_solutions(new_sols);
    refset.erase(refset.begin(),refset.end()-(b/2));

    for (int i = 0; i < (b/2); i++)
    {
        refset.push_back(new_sols[i]);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
leaq 0x99b3(%rip), %rbx      # 0x122b0
movq %rbx, %rdi
callq 0x6eed
movq 0x99ac(%rip), %rdx      # 0x122b8
leaq -0x1e0(%rdx), %rsi
movq %rbx, %rdi
callq 0xc818
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x7535
movq %rsp, %rdi
callq 0x74df
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x4dbe
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x8455
movq %rsp, %rbx
movq 0x10(%rbx), %rax
leaq 0x30(%rsp), %r14
movaps (%r14), %xmm0
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
movaps (%rbx), %xmm1
movaps %xmm0, (%rbx)
leaq 0x50(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
callq 0x4e5a
movq %r14, %rdi
callq 0x4e5a
leaq 0x18(%rsp), %rdi
callq 0x4e5a
movq %rbx, %rdi
callq 0x6eed
movq 0x98fc(%rip), %rsi      # 0x122b0
leaq 0x98f5(%rip), %rdi      # 0x122b0
movq $-0x1e0, %rdx           # imm = 0xFE20
addq 0x98ef(%rip), %rdx      # 0x122b8
callq 0xc818
xorl %r14d, %r14d
leaq 0x98d8(%rip), %rbx      # 0x122b0
movq (%rsp), %rsi
addq %r14, %rsi
movq %rbx, %rdi
callq 0x8c66
addq $0x60, %r14
cmpq $0x1e0, %r14            # imm = 0x1E0
jne 0x89d8
movq %rsp, %rdi
callq 0x4e5a
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x8a19
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4e5a
jmp 0x8a1c
jmp 0x8a19
jmp 0x8a19
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4e5a
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O3/cmaureir[P]strip-packing/scattersearch.cpp
// Function: get_difference(std::vector<solution, std::allocator<solution>>, std::vector<solution, std::allocator<solution>>)
int get_difference(vector<solution> before, vector<solution> after)
{
    //cout << "get_difference()" << endl;
    int total = 0;
    for (int i = 0; i < b; i++) {
        total += abs(before[i].fitness-after[i].fitness);
    }
    return total;
}

// Assembly:
movq (%rdi), %rcx
movq (%rsi), %rdx
xorl %esi, %esi
movaps 0x4665(%rip), %xmm0     # 0xd0a0
xorl %eax, %eax
movss 0x50(%rcx,%rsi), %xmm1
subss 0x50(%rdx,%rsi), %xmm1
andps %xmm0, %xmm1
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
addss %xmm1, %xmm2
cvttss2si %xmm2, %eax
addq $0x60, %rsi
cmpq $0x3c0, %rsi            # imm = 0x3C0
jne 0x8a3d
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/upload.cpp
// Function: main
int main(int argc, char *argv[])
{
	unsigned short port = 65535;

	if (argc < 3)
	{
		printf("Usage: upload filename port\r\n");
		return 0;
	}

	port = atoi(argv[2]);

	printf("Attempting to upload %s to client connecting on port %d\r\n", argv[1], (int)port);
	file_upload(argv[1], port);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x2, %edi
jg 0x176b
leaq 0xa71(%rip), %rdi       # 0x21d5
callq 0x11b0
jmp 0x179c
movq %rsi, %rbx
movq 0x10(%rsi), %rdi
callq 0x11c0
movq 0x8(%rbx), %rsi
movzwl %ax, %r14d
leaq 0x908(%rip), %rdi       # 0x208e
movl %r14d, %edx
xorl %eax, %eax
callq 0x1060
movq 0x8(%rbx), %rdi
movl %r14d, %esi
callq 0x151f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/Audio.cc
// Function: Audio::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void Audio::init(const std::string &str, int flag) {
    std::string err;
    switch (flag) {
        case 'd':
            if (is_dir(str)) from_dir(str);
            else {
                err = "please use directory";
                goto init_failed;
            }
            return;
        case 'f':
            if (is_wav(str)) from_file(str);
            else {
                err = "please write a wav file";
                goto init_failed;
            }
            return;
        case 'j':
            if (is_json(str)) from_json(str);
            else {
                err = "please use a json file";
                goto init_failed;
            }
            return;
        default:
            goto init_failed;
            break;
    }

init_failed:
    std::cout << err << std::endl;
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
cmpl $0x6a, %edx
je 0x6f27
cmpl $0x66, %edx
je 0x6f0e
cmpl $0x64, %edx
jne 0x6f97
movq (%rbx), %rdi
leaq 0x28(%rsp), %r15
movq %r15, %rsi
callq 0x32f0
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%r15), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x6f7d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x713a
jmp 0x6f4e
movq %rbx, %rsi
callq 0x78e4
testb %al, %al
je 0x6f86
movq %r14, %rdi
movq %rbx, %rsi
callq 0x798c
jmp 0x6f4e
leaq 0x7592(%rip), %rsi      # 0xe4c0
movl $0x5, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x35c0
cmpq $-0x1, %rax
je 0x6f74
movq %r14, %rdi
movq %rbx, %rsi
callq 0x73f4
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6f65
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3390
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x74ab(%rip), %rsi      # 0xe426
jmp 0x6f8d
leaq 0x7475(%rip), %rsi      # 0xe3f9
jmp 0x6f8d
leaq 0x7481(%rip), %rsi      # 0xe40e
leaq 0x8(%rsp), %rdi
callq 0x3460
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0xc018(%rip), %rdi      # 0x12fc0
callq 0x33d0
movq %rax, %rdi
callq 0x31a0
movl $0x1, %edi
callq 0x3410
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6fd9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3390
movq %rbx, %rdi
callq 0x35e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/Audio.cc
// Function: Audio::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Audio::init(const std::string &str) {
    if (is_dir(str)) {
        from_dir(str);
    } else if (is_json(str)) {
        from_json(str);
    } else if (is_wav(str)) {
        from_file(str);
    } else {
        std::cout << "not json or wav or dir" << std::endl;
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x32f0
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%r15), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x705b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x713a
leaq 0x745e(%rip), %rsi      # 0xe4c0
movl $0x5, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x35c0
cmpq $-0x1, %rax
je 0x708e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x73f4
movq %rbx, %rsi
callq 0x78e4
testb %al, %al
je 0x70b1
movq %r14, %rdi
movq %rbx, %rsi
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x798c
movq 0xbf08(%rip), %rdi      # 0x12fc0
leaq 0x7323(%rip), %rsi      # 0xe3e2
callq 0x3360
movq %rax, %rdi
callq 0x31a0
movl $0x1, %edi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/Audio.cc
// Function: Audio::is_wav(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool Audio::is_wav(const std::string &str) const {
    WAVE_HEADER header;
    std::ifstream f(str);

    if (f.is_open()) {
        f.read((char *)&header, sizeof(WAVE_HEADER));
        f.close();
        return tag_is_right(header.riff_id, header.riff_type);
    } else {
        f.close();
        return false;
    }
}

// Assembly:
pushq %rbx
subq $0x240, %rsp            # imm = 0x240
leaq 0x38(%rsp), %rdi
movl $0x8, %edx
callq 0x3550
leaq 0xb0(%rsp), %rdi
callq 0x30c0
testb %al, %al
je 0x7955
leaq 0x38(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x2c, %edx
callq 0x3440
leaq 0x38(%rsp), %rdi
callq 0x30a0
xorl %ebx, %ebx
cmpl $0x46464952, 0xc(%rsp)  # imm = 0x46464952
jne 0x7961
cmpb $0x57, 0x14(%rsp)
jne 0x7961
cmpb $0x41, 0x15(%rsp)
jne 0x7961
cmpb $0x56, 0x16(%rsp)
jne 0x7961
cmpb $0x45, 0x17(%rsp)
sete %bl
jmp 0x7961
leaq 0x38(%rsp), %rdi
callq 0x30a0
xorl %ebx, %ebx
leaq 0x38(%rsp), %rdi
callq 0x30e0
movl %ebx, %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbx
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x35e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/Audio.cc
// Function: Audio::tag_is_right(unsigned char const*, unsigned char const*) const
bool Audio::tag_is_right(const uint8_t *riff_id, const uint8_t *riff_type) const {
    return (riff_id[0] == 'R' && riff_id[1] == 'I' &&
           riff_id[2] == 'F' && riff_id[3] == 'F' &&
           riff_type[0] == 'W' && riff_type[1] == 'A' &&
           riff_type[2] == 'V' && riff_type[3] == 'E');
}

// Assembly:
cmpb $0x52, (%rsi)
jne 0x7c04
cmpb $0x49, 0x1(%rsi)
jne 0x7c04
cmpb $0x46, 0x2(%rsi)
jne 0x7c04
cmpb $0x46, 0x3(%rsi)
jne 0x7c04
cmpb $0x57, (%rdx)
jne 0x7c04
cmpb $0x41, 0x1(%rdx)
jne 0x7c04
cmpb $0x56, 0x2(%rdx)
jne 0x7c04
cmpb $0x45, 0x3(%rdx)
sete %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/Audio.cc
// Function: Audio::get_wav_by_code(unsigned short)
WAV_DATA Audio::get_wav_by_code(uint16_t code) {
    if (code > 255) {
        return {nullptr, 0, 0, 0};
    } else if (datas[code] > 255) {
        return {nullptr, 0, 0, 0};
    }
    return wav_datas[datas[code]];
}

// Assembly:
xorl %eax, %eax
movl $0x0, %edx
cmpl $0xff, %esi
ja 0x7c3e
movzwl %si, %eax
movzwl 0x1000(%rdi,%rax,2), %ecx
xorl %eax, %eax
movl $0x0, %edx
cmpq $0xff, %rcx
ja 0x7c3e
shll $0x4, %ecx
movq (%rdi,%rcx), %rax
movq 0x8(%rdi,%rcx), %rdx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/DeviceDetect.cc
// Function: get_event_id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static std::string get_event_id(std::string buf) {
    auto pos = buf.find("event");

    // 未找到event	if the event was not found
    if (pos == std::string::npos) return "";

    auto pos_stop = buf.find("/", pos);
    if (pos_stop == std::string::npos) pos_stop = buf.size();

    auto event_id = buf.substr(pos+5, pos_stop-pos-1);

    return event_id;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x59cb(%rip), %rsi      # 0xe58b
movl $0x5, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x35c0
cmpq $-0x1, %rax
je 0x8c16
movq %rax, %r15
leaq 0x585e(%rip), %rsi      # 0xe43d
movl $0x1, %ecx
movq %r14, %rdi
movq %rax, %rdx
callq 0x35c0
cmpq $-0x1, %rax
jne 0x8bf9
movq 0x8(%r14), %rax
leaq 0x5(%r15), %rdx
notq %r15
addq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x33a0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5c88(%rip), %rdx      # 0xe8ac
movq %rbx, %rdi
movq %rdx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7dac
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/Mixer.cc
// Function: Mixer::mix8(unsigned char*, unsigned int)
void Mixer::mix8(uint8_t *buf, uint32_t size) {
    if (buffer_end - pos < size) {
        // 传入的size要比pos 到 end大		The incoming size is larger than "pos" to "end"
        mtx.lock();
        for (int i = 0; i < buffer_end - pos; i++) {
            uint8_t A = *(pos + i);
            uint8_t B = *(buf + i);
            *(pos+i) = mix_uint8(A, B);
        }

        for (int i = 0; i < size - (buffer_end - pos); i++) {
            uint8_t A = *(buffer_start + i);
            uint8_t B = *(buf + (buffer_end - pos) + i);
            *(buffer_start+i) = mix_uint8(A, B);
        }

        mtx.unlock();
    } else {
        mtx.lock();
        for (int i = 0; i < size; i++) {
            uint8_t A = *(pos + i);
            uint8_t B = *(buf + i);
            *(pos+i) = mix_uint8(A, B);
        }
        mtx.unlock();
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movq 0x48(%rdi), %r15
subq 0x40(%rdi), %r15
movl %edx, %r14d
callq 0x34e0
cmpq %r14, %r15
jge 0x95a3
testl %eax, %eax
jne 0x95cf
movq 0x40(%rbx), %rax
movq 0x48(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
testq %rdx, %rdx
jle 0x9576
xorl %edx, %edx
movb $0x0, (%rax,%rdx)
incq %rdx
movq 0x40(%rbx), %rax
movq 0x48(%rbx), %rcx
movq %rcx, %rsi
subq %rax, %rsi
cmpq %rdx, %rsi
jg 0x955c
movq %r14, %rdx
subq %rcx, %rdx
addq %rax, %rdx
testq %rdx, %rdx
jle 0x95bd
xorl %eax, %eax
movq 0x38(%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq %r14, %rcx
subq 0x48(%rbx), %rcx
incq %rax
addq 0x40(%rbx), %rcx
cmpq %rax, %rcx
jg 0x9586
jmp 0x95bd
testl %eax, %eax
jne 0x95cf
testl %ebp, %ebp
je 0x95bd
xorl %eax, %eax
movq 0x40(%rbx), %rcx
movb $0x0, (%rcx,%rax)
incq %rax
cmpq %rax, %r14
jne 0x95ad
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x32a0
movl %eax, %edi
callq 0x3210
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/Mixer.cc
// Function: Mixer::mix16(unsigned char*, unsigned int)
void Mixer::mix16(uint8_t *buf, uint32_t size) {

    // 传入的buffer比较大， 超过了剩余的内存		The incoming buffer is relatively large and exceeds the remaining memory
    if (buffer_end - pos < size) {
        mtx.lock();
        for (int i = 0; i < (buffer_end-pos) / 2; i++) {
            int16_t A = *((int16_t *)pos + i);
            int16_t B = *((int16_t *)buf + i);
            *((int16_t *)pos + i) = mix_int16(A, B);
        }

        for (int i = 0; i < (size-(buffer_end-pos)) / 2; i++) {
            int16_t A = *((int16_t *)buffer_start + i);
            int16_t B = *((int16_t *)(buf + (buffer_end - pos)) + i);

            *((int16_t *)buffer_start + i) = mix_int16(A, B);
        }

        mtx.unlock();
    } else {
        mtx.lock();
        for (int i = 0; i < size / 2; i++) {
            int16_t A = *((int16_t *)pos + i);
            int16_t B = *((int16_t *)buf + i);
            *((int16_t *)pos + i) = mix_int16(A, B);
        }

        mtx.unlock();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %r13
subq 0x40(%rdi), %r13
movl %edx, %r12d
callq 0x34e0
cmpq %r12, %r13
jge 0x96e1
testl %eax, %eax
jne 0x974a
movq 0x40(%rbx), %rcx
movq 0x48(%rbx), %rax
subq %rcx, %rax
cmpq $0x2, %rax
jl 0x9673
movq %rax, %rdx
shrq $0x3f, %rdx
addq %rax, %rdx
sarq %rdx
xorl %esi, %esi
movl $0x8012, %edi           # imm = 0x8012
movl $0x7fee, %r8d           # imm = 0x7FEE
movswl (%rcx,%rsi,2), %r9d
movswl (%r14,%rsi,2), %r10d
leal (%r10,%r9), %r11d
imull %r9d, %r10d
sarl $0x10, %r10d
subl %r10d, %r11d
cmpl $0xffff8000, %r11d      # imm = 0xFFFF8000
movl %r11d, %r9d
cmovll %edi, %r9d
cmpl $0x8000, %r11d          # imm = 0x8000
cmovgel %r8d, %r9d
movw %r9w, (%rcx,%rsi,2)
incq %rsi
cmpq %rsi, %rdx
jne 0x9634
subq %rax, %r12
cmpq $0x2, %r12
jl 0x9739
movq %r12, %rcx
shrq $0x3f, %rcx
addq %r12, %rcx
sarq %rcx
movq 0x38(%rbx), %rdx
addq %rax, %r14
xorl %eax, %eax
movl $0x8012, %esi           # imm = 0x8012
movl $0x7fee, %edi           # imm = 0x7FEE
movswl (%rdx,%rax,2), %r8d
movswl (%r14,%rax,2), %r9d
leal (%r9,%r8), %r10d
imull %r8d, %r9d
sarl $0x10, %r9d
subl %r9d, %r10d
cmpl $0xffff8000, %r10d      # imm = 0xFFFF8000
movl %r10d, %r8d
cmovll %esi, %r8d
cmpl $0x8000, %r10d          # imm = 0x8000
cmovgel %edi, %r8d
movw %r8w, (%rdx,%rax,2)
incq %rax
cmpq %rax, %rcx
jne 0x96a0
jmp 0x9739
testl %eax, %eax
jne 0x974a
cmpl $0x2, %r15d
jb 0x9739
shrl %r15d
movq 0x40(%rbx), %rax
xorl %ecx, %ecx
movl $0x8012, %edx           # imm = 0x8012
movl $0x7fee, %esi           # imm = 0x7FEE
movswl (%rax,%rcx,2), %edi
movswl (%r14,%rcx,2), %r8d
leal (%r8,%rdi), %r9d
imull %edi, %r8d
sarl $0x10, %r8d
subl %r8d, %r9d
cmpl $0xffff8000, %r9d       # imm = 0xFFFF8000
movl %r9d, %edi
cmovll %edx, %edi
cmpl $0x8000, %r9d           # imm = 0x8000
cmovgel %esi, %edi
movw %di, (%rax,%rcx,2)
incq %rcx
cmpq %rcx, %r15
jne 0x96fe
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x32a0
movl %eax, %edi
callq 0x3210
nop
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/Mixer.cc
// Function: Mixer::mix32(unsigned char*, unsigned int)
void Mixer::mix32(uint8_t *buf, uint32_t size) {
    // 传入的buffer比较大，		The incoming buffer is relatively large,
    // 超过了剩余的内存			Exceeded the remaining memory
    if (buffer_end - pos < size) {
        mtx.lock();
        for (int i = 0; i < (buffer_end-pos) / 4; i++) {
            int32_t A = *((int32_t *)pos + i);
            int32_t B = *((int32_t *)buf + i);
            *((int32_t *)pos + i) = mix_int32(A, B);
        }

        for (int i = 0; i < (size-(buffer_end-pos)) / 4; i++) {
            int32_t A = *((int32_t *)buffer_start + i);
            int32_t B = *((int32_t *)(buf + (buffer_end - pos)) + i);

            *((int32_t *)buffer_start + i) = mix_int32(A, B);
        }

        mtx.unlock();
    } else {
        mtx.lock();
        for (int i = 0; i < size / 4; i++) {
            int32_t A = *((int32_t *)pos + i);
            int32_t B = *((int32_t *)buf + i);
            *((int32_t *)pos + i) = mix_int32(A, B);
        }

        mtx.unlock();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %r13
subq 0x40(%rdi), %r13
movl %edx, %r12d
callq 0x34e0
cmpq %r12, %r13
jge 0x9839
testl %eax, %eax
jne 0x9892
movq 0x40(%rbx), %rcx
movq 0x48(%rbx), %rax
subq %rcx, %rax
leaq 0x3(%rax), %rdx
testq %rax, %rax
cmovnsq %rax, %rdx
cmpq $0x4, %rax
jl 0x97dc
sarq $0x2, %rdx
xorl %esi, %esi
movslq (%rcx,%rsi,4), %rdi
movslq (%r14,%rsi,4), %r8
leaq (%r8,%rdi), %r9
imulq %rdi, %r8
sarq $0x20, %r8
subq %r8, %r9
xorl %edi, %edi
cmpq $0x7fffffff, %r9        # imm = 0x7FFFFFFF
setle %dil
addl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movl %edi, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x97a7
subq %rax, %r12
leaq 0x3(%r12), %rcx
testq %r12, %r12
cmovnsq %r12, %rcx
cmpq $0x4, %r12
jl 0x9881
sarq $0x2, %rcx
movq 0x38(%rbx), %rdx
addq %rax, %r14
xorl %eax, %eax
movslq (%rdx,%rax,4), %rsi
movslq (%r14,%rax,4), %rdi
leaq (%rdi,%rsi), %r8
imulq %rsi, %rdi
sarq $0x20, %rdi
subq %rdi, %r8
xorl %esi, %esi
cmpq $0x7fffffff, %r8        # imm = 0x7FFFFFFF
setle %sil
addl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movl %esi, (%rdx,%rax,4)
incq %rax
cmpq %rax, %rcx
jne 0x9802
jmp 0x9881
testl %eax, %eax
jne 0x9892
cmpl $0x4, %r15d
jb 0x9881
shrl $0x2, %r15d
movq 0x40(%rbx), %rax
xorl %ecx, %ecx
movslq (%rax,%rcx,4), %rdx
movslq (%r14,%rcx,4), %rsi
leaq (%rsi,%rdx), %rdi
imulq %rdx, %rsi
sarq $0x20, %rsi
subq %rsi, %rdi
xorl %edx, %edx
cmpq $0x7fffffff, %rdi       # imm = 0x7FFFFFFF
setle %dl
addl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl %edx, (%rax,%rcx,4)
incq %rcx
cmpq %rcx, %r15
jne 0x984d
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x32a0
movl %eax, %edi
callq 0x3210
nop
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/Mixer.cc
// Function: Mixer::get_mix(void (*)(unsigned char*, unsigned int), unsigned int)
void Mixer::get_mix(call_back func, uint32_t size) {
    // 取数据，pos会移动		Fetch data, pos will move
    mtx.lock();

    uint32_t buf_pos = 0;
    // uint32_t need = size;

    // 所需大于0		Need to be greater than 0
    while (size - buf_pos > 0) {
        if (size - buf_pos > buffer_end - pos) {
            // 所需大于mixer的buffer的当前位置到结尾	The current position to the end of the buffer that needs to be larger than the mixer
            func(pos, buffer_end - pos);
            // 拷贝过后的数据归0			Return the data after copying to 0
            std::memset(pos, 0, buffer_end-pos);
            buf_pos += buffer_end - pos;
            pos = buffer_start;
        } else {
            // 所需小于mixer的buffer当前位置到结尾	The current position of the buffer that needs to be smaller than the mixer to the end
            func(pos, size - buf_pos);
            std::memset(pos, 0, size - buf_pos);
            pos += size - buf_pos;

            // buf_pos += (size - buf_pos);
            break;
        }
    }

    // // 请求的数据块大于剩余的数据块，正常应该不会出现这种情况	The requested data block is larger than the remaining data blocks, normally this should not happen
    // if (size > buffer_end - pos) {
        // func(pos, buffer_end - pos);
        // std::memset(pos, 0, buffer_end-pos);

        // uint32_t left = size - (buffer_end - pos);
        // pos = buffer_start;
        // func(pos, left);
        // std::memset(pos, 0, left);
        // pos += left;

    // } else {
        // func(pos, size);
        // std::memset(pos, 0, size);
        // pos += size;
    // }
    mtx.unlock();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x34e0
testl %eax, %eax
jne 0x992b
testl %ebp, %ebp
je 0x991b
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rsi
xorl %r12d, %r12d
movl %ebp, %eax
movl %eax, %r15d
subq %rdi, %rsi
cmpq %r15, %rsi
jge 0x9903
callq *%r14
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rdx
subq %rdi, %rdx
xorl %esi, %esi
callq 0x31d0
movq 0x38(%rbx), %rdi
movq 0x48(%rbx), %rsi
movl 0x40(%rbx), %eax
movl %esi, %ecx
subl %eax, %ecx
addl %ecx, %r12d
movq %rdi, 0x40(%rbx)
movl %ebp, %eax
subl %r12d, %eax
jne 0x98c4
jmp 0x991b
movl %r15d, %esi
callq *%r14
movq 0x40(%rbx), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x31d0
addq %r15, 0x40(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x32a0
movl %eax, %edi
callq 0x3210
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/Mixer.cc
// Function: Mixer::get_mix(unsigned char*, unsigned int)
void Mixer::get_mix(uint8_t *buf, uint32_t size) {
    // 取数据，pos会移动	Fetch data, pos will move
    mtx.lock();

    uint32_t buf_pos = 0;
    // uint32_t need = size;

    while (size - buf_pos > 0) {
        if (size - buf_pos > buffer_end - pos) {
            std::memcpy(buf + buf_pos, pos, buffer_end - pos);
            // 拷贝过后的数据归0	Return the data after copying to 0
            std::memset(pos, 0, buffer_end-pos);
            buf_pos += buffer_end - pos;
            pos = buffer_start;
        } else {
            std::memcpy(buf + buf_pos, pos, size - buf_pos);
            std::memset(pos, 0, size - buf_pos);
            pos += size - buf_pos;

            // buf_pos += (size - buf_pos);
            break;
        }
    }

    // // 请求的数据块大于剩余的数据块		The requested data block is larger than the remaining data block
    // if (size > buffer_end - pos) {
        // std::cout << "---------------------" << std::endl;
        // std::cout << "pos start " << pos - buffer_start << std::endl;
        // std::cout << "size " << size << std::endl;
        // std::cout << "buffer_end - pos " << buffer_end - pos << std::endl;
        // std::memcpy(buf, pos, buffer_end - pos);
        // // 拷贝过后的数据归0			Return the data after copying to 0
        // std::memset(pos, 0, buffer_end-pos);

        // uint32_t left = size - (buffer_end - pos);
        // std::cout << "left is " << size - (buffer_end - pos) << std::endl;
        // std::memcpy(buf + (buffer_end - pos), buffer_start, left);
        // std::cout << "buf + (bufend - pos) " << (buffer_end - pos) << std::endl;
        // std::memset(buffer_start, 0, left);

        // pos = buffer_start + left;
        // std::cout << "pos end " << pos - buffer_start << std::endl;

    // } else {
        // std::memcpy(buf, pos, size);
        // std::memset(pos, 0, size);
        // pos += size;
    // }
    mtx.unlock();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x34e0
testl %eax, %eax
jne 0x99d0
testl %ebp, %ebp
je 0x99c0
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
xorl %r12d, %r12d
movl %ebp, %r15d
subl %r12d, %r15d
subq %rsi, %rdx
movl %r12d, %edi
addq %r14, %rdi
cmpq %r15, %rdx
jge 0x99a6
callq 0x32c0
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rdx
subq %rdi, %rdx
xorl %esi, %esi
callq 0x31d0
movq 0x38(%rbx), %rsi
movq 0x48(%rbx), %rdx
movl 0x40(%rbx), %eax
movl %edx, %ecx
subl %eax, %ecx
addl %ecx, %r12d
movq %rsi, 0x40(%rbx)
cmpl %ebp, %r12d
jne 0x995e
jmp 0x99c0
movq %r15, %rdx
callq 0x32c0
movq 0x40(%rbx), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x31d0
addq %r15, 0x40(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x32a0
movl %eax, %edi
callq 0x3210
nop
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/cJSON.cc
// Function: cJSON_InitHooks
void cJSON_InitHooks(cJSON_Hooks* hooks)
{
    if (!hooks) { /* Reset hooks */
        cJSON_malloc = malloc;
        cJSON_free = free;
        return;
    }

	cJSON_malloc = (hooks->malloc_fn)?hooks->malloc_fn:malloc;
	cJSON_free	 = (hooks->free_fn)?hooks->free_fn:free;
}

// Assembly:
testq %rdi, %rdi
je 0x9c02
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
testq %rcx, %rcx
jne 0x9bf4
movq 0x93d4(%rip), %rcx      # 0x12fc8
testq %rax, %rax
jne 0x9c10
movq 0x93b8(%rip), %rax      # 0x12fb8
jmp 0x9c10
movq 0x93af(%rip), %rax      # 0x12fb8
movq 0x93b8(%rip), %rcx      # 0x12fc8
movq %rcx, 0x9729(%rip)      # 0x13340
movq %rax, 0x972a(%rip)      # 0x13348
retq
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/cJSON.cc
// Function: cJSON_Delete
void cJSON_Delete(cJSON *c)
{
	cJSON *next;
	while (c)
	{
		next=c->next;
		if (!(c->type&cJSON_IsReference) && c->child) cJSON_Delete(c->child);
		if (!(c->type&cJSON_IsReference) && c->valuestring) cJSON_free(c->valuestring);
		if (!(c->type&cJSON_StringIsConst) && c->string) cJSON_free(c->string);
		cJSON_free(c);
		c=next;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x9c90
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rbx, %r14
movq (%rbx), %rbx
movl 0x18(%r14), %eax
btl $0x8, %eax
jb 0x9c4d
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x9c4d
callq 0x9c1f
movl 0x18(%r14), %eax
btl $0x8, %eax
jb 0x9c66
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x9c66
callq *0x96e6(%rip)           # 0x13348
movl 0x18(%r14), %eax
btl $0x9, %eax
jb 0x9c7b
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x9c7b
callq *0x96cd(%rip)           # 0x13348
movq %r14, %rdi
callq *0x96c4(%rip)           # 0x13348
testq %rbx, %rbx
jne 0x9c2b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/cJSON.cc
// Function: cJSON_ParseWithOpts
cJSON *cJSON_ParseWithOpts(const char *value,const char **return_parse_end,int require_null_terminated)
{
	const char *end=0;
	cJSON *c=cJSON_New_Item();
	ep=0;
	if (!c) return 0;       /* memory fail */

	end=parse_value(c,skip(value));
	if (!end)	{cJSON_Delete(c);return 0;}	/* parse failure. ep is set. */

	/* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
	if (require_null_terminated) {end=skip(end);if (*end) {cJSON_Delete(c);ep=end;return 0;}}
	if (return_parse_end) *return_parse_end=end;
	return c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl $0x40, %edi
callq *0x9695(%rip)           # 0x13340
testq %rax, %rax
je 0x9ce7
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0xbf30(%rip) # 0x15c00
testq %r15, %r15
je 0x9cf4
decq %r15
movb 0x1(%r15), %al
incq %r15
decb %al
cmpb $0x20, %al
jb 0x9cd8
jmp 0x9cf7
movq $0x0, 0xbf0e(%rip) # 0x15c00
jmp 0x9d47
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9d57
testq %rax, %rax
je 0x9d3f
movq %rax, %r15
testl %ebp, %ebp
je 0x9d35
decq %r15
movb 0x1(%r15), %al
incq %r15
leal -0x1(%rax), %ecx
cmpb $0x20, %cl
jb 0x9d11
testb %al, %al
je 0x9d35
movq %rbx, %rdi
callq 0x9c1f
movq %r15, 0xbecd(%rip)      # 0x15c00
jmp 0x9d47
testq %r14, %r14
je 0x9d49
movq %r15, (%r14)
jmp 0x9d49
movq %rbx, %rdi
callq 0x9c1f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/cJSON.cc
// Function: print_value(cJSON*, int, int, printbuffer*)
static char *print_value(cJSON *item,int depth,int fmt,printbuffer *p)
{
	char *out=0;
	if (!item) return 0;
	if (p)
	{
		switch ((item->type)&255)
		{
			case cJSON_NULL:	{out=ensure(p,5);	if (out) strcpy(out,"null");	break;}
			case cJSON_False:	{out=ensure(p,6);	if (out) strcpy(out,"false");	break;}
			case cJSON_True:	{out=ensure(p,5);	if (out) strcpy(out,"true");	break;}
			case cJSON_Number:	out=print_number(item,p);break;
			case cJSON_String:	out=print_string(item,p);break;
			case cJSON_Array:	out=print_array(item,depth,fmt,p);break;
			case cJSON_Object:	out=print_object(item,depth,fmt,p);break;
		}
	}
	else
	{
		switch ((item->type)&255)
		{
			case cJSON_NULL:	out=cJSON_strdup("null");	break;
			case cJSON_False:	out=cJSON_strdup("false");break;
			case cJSON_True:	out=cJSON_strdup("true"); break;
			case cJSON_Number:	out=print_number(item,0);break;
			case cJSON_String:	out=print_string(item,0);break;
			case cJSON_Array:	out=print_array(item,depth,fmt,0);break;
			case cJSON_Object:	out=print_object(item,depth,fmt,0);break;
		}
	}
	return out;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xa0c8
movb 0x18(%rdi), %al
testq %rcx, %rcx
je 0xa013
cmpb $0x6, %al
ja 0xa0c8
movzbl %al, %eax
leaq 0x4815(%rip), %r8       # 0xe810
movslq (%r8,%rax,4), %rax
addq %r8, %rax
jmpq *%rax
movq %rcx, %rdi
movl $0x6, %esi
callq 0xb2da
jmp 0xa039
cmpb $0x6, %al
ja 0xa0c8
movzbl %al, %eax
leaq 0x4807(%rip), %rcx      # 0xe82c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x6, %edi
callq *0x9307(%rip)           # 0x13340
testq %rax, %rax
je 0xa0c8
movw $0x65, 0x4(%rax)
movl $0x736c6166, (%rax)     # imm = 0x736C6166
jmp 0xa0ca
movq %rcx, %rdi
movl $0x5, %esi
callq 0xb2da
jmp 0xa093
movq %rcx, %rdi
movl $0x5, %esi
callq 0xb2da
jmp 0xa0b7
movq %rcx, %rsi
jmp 0xa0a6
movq 0x20(%rdi), %rdi
movq %rcx, %rsi
jmp 0xa082
movq 0x20(%rdi), %rdi
xorl %esi, %esi
popq %rax
jmp 0xbdcb
movl $0x5, %edi
callq *0x92ad(%rip)           # 0x13340
testq %rax, %rax
je 0xa0c8
movb $0x0, 0x4(%rax)
movl $0x6c6c756e, (%rax)     # imm = 0x6C6C756E
jmp 0xa0ca
xorl %esi, %esi
popq %rax
jmp 0xb378
movl $0x5, %edi
callq *0x9289(%rip)           # 0x13340
testq %rax, %rax
je 0xa0c8
movb $0x0, 0x4(%rax)
movl $0x65757274, (%rax)     # imm = 0x65757274
jmp 0xa0ca
xorl %eax, %eax
popq %rcx
retq
xorl %ecx, %ecx
popq %rax
jmp 0xb500
xorl %ecx, %ecx
popq %rax
jmp 0xb7f7
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/cJSON.cc
// Function: cJSON_PrintBuffered
char *cJSON_PrintBuffered(cJSON *item,int prebuffer,int fmt)
{
	printbuffer p;
	p.buffer=(char*)cJSON_malloc(prebuffer);
	p.length=prebuffer;
	p.offset=0;
	return print_value(item,0,fmt,&p);
	return p.buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r14
movslq %esi, %r15
movq %r15, %rdi
callq *0x923f(%rip)           # 0x13340
movq %rsp, %rcx
movq %rax, (%rcx)
movl %r15d, 0x8(%rcx)
movl $0x0, 0xc(%rcx)
movq %r14, %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x9fd7
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/cJSON.cc
// Function: cJSON_Duplicate
cJSON *cJSON_Duplicate(cJSON *item,int recurse)
{
	cJSON *newitem,*cptr,*nptr=0,*newchild;
	/* Bail on bad ptr */
	if (!item) return 0;
	/* Create new item */
	newitem=cJSON_New_Item();
	if (!newitem) return 0;
	/* Copy over all vars */
	newitem->type=item->type&(~cJSON_IsReference),newitem->valueint=item->valueint,newitem->valuedouble=item->valuedouble;
	if (item->valuestring)	{newitem->valuestring=cJSON_strdup(item->valuestring);	if (!newitem->valuestring)	{cJSON_Delete(newitem);return 0;}}
	if (item->string)		{newitem->string=cJSON_strdup(item->string);			if (!newitem->string)		{cJSON_Delete(newitem);return 0;}}
	/* If non-recursive, then we're done! */
	if (!recurse) return newitem;
	/* Walk the ->next chain for the child. */
	cptr=item->child;
	while (cptr)
	{
		newchild=cJSON_Duplicate(cptr,1);		/* Duplicate (with recurse) each item in the ->next chain */
		if (!newchild) {cJSON_Delete(newitem);return 0;}
		if (nptr)	{nptr->next=newchild,newchild->prev=nptr;nptr=newchild;}	/* If newitem->child already set, then crosswire ->prev and ->next and move on */
		else		{newitem->child=newchild;nptr=newchild;}					/* Set newitem->child and move to it */
		cptr=cptr->next;
	}
	return newitem;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xabf6
movl %esi, %ebp
movq %rdi, %r14
movl $0x40, %edi
callq *0x885b(%rip)           # 0x13340
testq %rax, %rax
je 0xabf6
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movl $0xfffffeff, %eax       # imm = 0xFFFFFEFF
andl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
movsd 0x30(%r14), %xmm0
movsd %xmm0, 0x30(%rbx)
movq 0x20(%r14), %r15
testq %r15, %r15
je 0xab5f
movq %r15, %rdi
callq 0x3170
movq %rax, %r12
incq %r12
movq %r12, %rdi
callq *0x87ff(%rip)           # 0x13340
testq %rax, %rax
je 0xabda
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x32c0
movq %r13, 0x20(%rbx)
movq 0x38(%r14), %r15
testq %r15, %r15
je 0xab99
movq %r15, %rdi
callq 0x3170
movq %rax, %r12
incq %r12
movq %r12, %rdi
callq *0x87c1(%rip)           # 0x13340
testq %rax, %rax
je 0xabe1
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x32c0
movq %r13, 0x38(%rbx)
testl %ebp, %ebp
je 0xabf8
movq 0x10(%r14), %r14
testq %r14, %r14
je 0xabf8
xorl %r15d, %r15d
movq %r14, %rdi
movl $0x1, %esi
callq 0xaac1
testq %rax, %rax
je 0xabee
testq %r15, %r15
je 0xabc9
movq %rax, (%r15)
movq %r15, 0x8(%rax)
jmp 0xabcd
movq %rax, 0x10(%rbx)
movq (%r14), %r14
movq %rax, %r15
testq %r14, %r14
jne 0xaba9
jmp 0xabf8
movl $0x20, %eax
jmp 0xabe6
movl $0x38, %eax
movq $0x0, (%rbx,%rax)
movq %rbx, %rdi
callq 0x9c1f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/cJSON.cc
// Function: cJSON_Minify
void cJSON_Minify(char *json)
{
	char *into=json;
	while (*json)
	{
		if (*json==' ') json++;
		else if (*json=='\t') json++;	/* Whitespace characters. */
		else if (*json=='\r') json++;
		else if (*json=='\n') json++;
		else if (*json=='/' && json[1]=='/')  while (*json && *json!='\n') json++;	/* double-slash comments, to end of line. */
		else if (*json=='/' && json[1]=='*') {while (*json && !(*json=='*' && json[1]=='/')) json++;json+=2;}	/* multiline comments. */
		else if (*json=='\"'){*into++=*json++;while (*json && *json!='\"'){if (*json=='\\') *into++=*json++;*into++=*json++;}*into++=*json++;} /* string literals, which are \" sensitive. */
		else *into++=*json++;			/* All other characters. */
	}
	*into=0;	/* and null-terminate. */
}

// Assembly:
movq %rdi, %rax
movb (%rdi), %cl
movzbl %cl, %edx
cmpl $0x1f, %edx
jg 0xac2b
cmpl $0x9, %edx
jle 0xac3f
cmpl $0xa, %edx
je 0xac45
cmpl $0xd, %edx
je 0xac45
jmp 0xacd7
cmpl $0x2f, %edx
je 0xac4a
cmpl $0x22, %edx
je 0xac93
cmpl $0x20, %edx
je 0xac45
jmp 0xacd7
jne 0xacd3
incq %rdi
jmp 0xac0d
movzbl 0x1(%rdi), %edx
cmpl $0x2f, %edx
je 0xac82
cmpl $0x2a, %edx
jne 0xacd7
addq $0x2, %rdi
movb $0x2f, %cl
cmpb $0x2a, %cl
je 0xac6f
movzbl %cl, %ecx
testl %ecx, %ecx
je 0xac0d
movb -0x1(%rdi), %cl
jmp 0xac77
movb -0x1(%rdi), %cl
cmpb $0x2f, %cl
je 0xac0d
incq %rdi
jmp 0xac5e
movb 0x1(%rdi), %dl
incq %rdi
testb %dl, %dl
je 0xac0d
movzbl %dl, %ecx
cmpl $0xa, %ecx
jne 0xac7c
jmp 0xac0d
movb $0x22, (%rax)
movzbl 0x1(%rdi), %ecx
cmpl $0x5c, %ecx
je 0xacb0
testl %ecx, %ecx
je 0xacc3
cmpl $0x22, %ecx
je 0xacc3
incq %rax
incq %rdi
jmp 0xacbf
movb $0x5c, 0x1(%rax)
addq $0x2, %rax
movb 0x2(%rdi), %cl
addq $0x2, %rdi
movb %cl, (%rax)
jmp 0xac96
addq $0x2, %rdi
movb %cl, 0x1(%rax)
addq $0x2, %rax
jmp 0xac0d
testl %edx, %edx
je 0xace4
incq %rdi
movb %cl, (%rax)
incq %rax
jmp 0xac0d
movb $0x0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/cJSON.cc
// Function: parse_array(cJSON*, char const*)
static const char *parse_array(cJSON *item,const char *value)
{
	cJSON *child;
	if (*value!='[')	{ep=value;return 0;}	/* not an array! */

	item->type=cJSON_Array;
	value=skip(value+1);
	if (*value==']') return value+1;	/* empty array. */

	item->child=child=cJSON_New_Item();
	if (!item->child) return 0;		 /* memory fail */
	value=skip(parse_value(child,skip(value)));	/* skip any spacing, get the value. */
	if (!value) return 0;

	while (*value==',')
	{
		cJSON *new_item;
		if (!(new_item=cJSON_New_Item())) return 0; 	/* memory fail */
		child->next=new_item;new_item->prev=child;child=new_item;
		value=skip(parse_value(child,skip(value+1)));
		if (!value) return 0;	/* memory fail */
	}

	if (*value==']') return value+1;	/* end of array */
	ep=value;return 0;	/* malformed. */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x5b, (%rsi)
jne 0xafff
movq %rdi, %r14
movl $0x5, 0x18(%rdi)
incq %rbx
movb (%rbx), %al
leal -0x1(%rax), %ecx
incq %rbx
cmpb $0x20, %cl
jb 0xaf17
cmpb $0x5d, %al
je 0xb008
movl $0x40, %edi
callq *0x8409(%rip)           # 0x13340
testq %rax, %rax
je 0xb017
movq %rax, %r15
addq $-0x2, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq %rax, 0x10(%r14)
movb 0x1(%rbx), %al
incq %rbx
decb %al
cmpb $0x20, %al
jb 0xaf5d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9d57
testq %rax, %rax
je 0xb006
movq %rax, %r14
decq %r14
movb 0x1(%r14), %al
incq %r14
leal -0x1(%rax), %ecx
cmpb $0x20, %cl
jb 0xaf83
xorl %ebx, %ebx
cmpb $0x2c, %al
jne 0xb021
movl $0x40, %edi
callq *0x8399(%rip)           # 0x13340
testq %rax, %rax
je 0xb008
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq %rax, (%r15)
movq %r15, 0x8(%rax)
movb 0x1(%r14), %al
incq %r14
decb %al
cmpb $0x20, %al
jb 0xafc8
movq %r12, %rdi
movq %r14, %rsi
callq 0x9d57
testq %rax, %rax
je 0xb008
movq %rax, %r14
decq %r14
movb 0x1(%r14), %al
incq %r14
leal -0x1(%rax), %ecx
cmpb $0x20, %cl
jb 0xafeb
movq %r12, %r15
jmp 0xaf94
movq %rbx, 0xabfa(%rip)      # 0x15c00
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq $0x0, 0x10(%r14)
jmp 0xb006
movzbl %al, %eax
cmpl $0x5d, %eax
jne 0xb031
incq %r14
movq %r14, %rbx
jmp 0xb008
movq %r14, 0xabc8(%rip)      # 0x15c00
jmp 0xb006
// File: /workspace/github_cpp_makefile_star2_O3/fgheng[P]keysound/src/cJSON.cc
// Function: parse_hex4(char const*)
static unsigned parse_hex4(const char *str)
{
	unsigned h=0;
	if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0;
	h=h<<4;str++;
	if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0;
	h=h<<4;str++;
	if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0;
	h=h<<4;str++;
	if (*str>='0' && *str<='9') h+=(*str)-'0'; else if (*str>='A' && *str<='F') h+=10+(*str)-'A'; else if (*str>='a' && *str<='f') h+=10+(*str)-'a'; else return 0;
	return h;
}

// Assembly:
movb (%rdi), %cl
leal -0x30(%rcx), %eax
cmpb $0xa, %al
jb 0xb242
leal -0x41(%rcx), %eax
cmpb $0x5, %al
ja 0xb232
addb $-0x37, %cl
jmp 0xb240
leal -0x61(%rcx), %eax
cmpb $0x5, %al
ja 0xb2d7
addb $-0x57, %cl
movl %ecx, %eax
movb 0x1(%rdi), %dl
leal -0x30(%rdx), %ecx
cmpb $0xa, %cl
jb 0xb267
leal -0x41(%rdx), %ecx
cmpb $0x5, %cl
ja 0xb25a
addb $-0x37, %dl
jmp 0xb265
leal -0x61(%rdx), %ecx
cmpb $0x5, %cl
ja 0xb2d7
addb $-0x57, %dl
movl %edx, %ecx
movb 0x2(%rdi), %sil
leal -0x30(%rsi), %edx
cmpb $0xa, %dl
jb 0xb28f
leal -0x41(%rsi), %edx
cmpb $0x5, %dl
ja 0xb281
addb $-0x37, %sil
jmp 0xb28d
leal -0x61(%rsi), %edx
cmpb $0x5, %dl
ja 0xb2d7
addb $-0x57, %sil
movl %esi, %edx
movb 0x3(%rdi), %sil
leal -0x30(%rsi), %edi
cmpb $0xa, %dil
jb 0xb2ba
leal -0x41(%rsi), %edi
cmpb $0x5, %dil
ja 0xb2ab
addb $-0x37, %sil
jmp 0xb2b8
leal -0x61(%rsi), %edi
cmpb $0x5, %dil
ja 0xb2d7
addb $-0x57, %sil
movl %esi, %edi
movzbl %al, %eax
movzbl %cl, %ecx
shll $0x8, %eax
shll $0x4, %ecx
addl %eax, %ecx
movzbl %dl, %edx
addl %ecx, %edx
shll $0x4, %edx
movzbl %dil, %eax
addl %edx, %eax
retq
xorl %eax, %eax
retq