LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/eschwabe[P]interview-practice/src/zeromatrix.cpp
// Function: main
int main()
{
    // allocate matrix
    const int ROWS = 10;
    const int COLS = 7;
    int* matrix[ROWS];
    for(int r = 0; r < ROWS; r++) {
        matrix[r] = new int[COLS];
    }

    // initialize matrix
    for(int r = 0; r < ROWS; r++) {
        for(int c = 0; c < COLS; c++) {
            matrix[r][c] = r+c;
        }
    }
    matrix[ROWS/2][COLS/2+2] = 0;

    // print and set zeros
    PrintMatrix(matrix, ROWS, COLS);
    PropogateZeros(matrix, ROWS, COLS);
    PrintMatrix(matrix, ROWS, COLS);

    return 0;
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
xorl %ebx, %ebx
movl $0x1c, %edi
callq 0x1030
movq %rax, (%rsp,%rbx,8)
incq %rbx
cmpq $0xa, %rbx
jne 0x13a4
movl $0x1, %eax
xorl %ecx, %ecx
movdqa 0xc46(%rip), %xmm0      # 0x2010
movdqa 0xc4e(%rip), %xmm1      # 0x2020
movdqa 0xc56(%rip), %xmm2      # 0x2030
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movdqa 0xc59(%rip), %xmm4      # 0x2040
movq (%rsp,%rcx,8), %rdx
xorl %esi, %esi
movdqa %xmm0, %xmm5
movdqa %xmm5, %xmm6
pxor %xmm1, %xmm6
movdqa %xmm2, %xmm7
pcmpgtd %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
pcmpeqd %xmm3, %xmm6
pand %xmm7, %xmm6
movd %xmm6, %edi
testb $0x1, %dil
je 0x141e
leal (%rcx,%rsi), %edi
movl %edi, (%rdx,%rsi,4)
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x1430
leal (%rax,%rsi), %edi
movl %edi, 0x4(%rdx,%rsi,4)
addq $0x2, %rsi
paddq %xmm4, %xmm5
cmpq $0x8, %rsi
jne 0x13f1
incq %rcx
incq %rax
cmpq $0xa, %rcx
jne 0x13e7
movq %rsp, %rbx
movq 0x28(%rbx), %rax
movl $0x0, 0x14(%rax)
movq %rbx, %rdi
movl $0xa, %esi
movl $0x7, %edx
callq 0x12e3
movq %rbx, %rdi
movl $0xa, %esi
movl $0x7, %edx
callq 0x11ec
movq %rbx, %rdi
movl $0xa, %esi
movl $0x7, %edx
callq 0x12e3
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/zheng-ji[P]lruCache/./lrucache.h
// Function: LRUCache<int, int>::GetCache(int const&, int&, bool)
int GetCache(const T & t, Value & value, bool bUpdate = true) 
        {
            std::lock_guard<std::mutex> lck(mt);
            HashMapIter mapIter = m_LRUCache.find(t);

            if (mapIter == m_LRUCache.end())
                return -1;

            mapIter = m_LRUCache.find(t);

            if (mapIter != m_LRUCache.end()) 
            {
                if (m_iTimeLimit > 0) 
                {
                    time_t tNow = time(NULL);
                    if (tNow - mapIter->second.updatetime > m_iTimeLimit) 
                    {
                        return -2;
                    }
                }

                value = mapIter->second.value;

                if (bUpdate) 
                {
                    m_List.erase(mapIter->second.listiter);
                    m_List.push_front(t);
                    mapIter->second.listiter = m_List.begin();
                }

                return m_iCacheSize;
            }

            return -3;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
movq %rdx, -0x38(%rbp)
movq %rsi, %r15
movq %rdi, %r14
leaq 0x60(%rdi), %rbx
movq %rbx, %rdi
callq 0x21b0
testl %eax, %eax
jne 0x2855
leaq 0x18(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2b16
testq %rax, %rax
je 0x282d
movl %r13d, -0x2c(%rbp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x2b16
movq %rax, %r12
testq %rax, %rax
je 0x2835
cmpl $0x0, 0x5c(%r14)
jle 0x27d3
xorl %edi, %edi
callq 0x2120
subq 0x20(%r12), %rax
movslq 0x5c(%r14), %rcx
movl $0xfffffffe, %r13d      # imm = 0xFFFFFFFE
cmpq %rcx, %rax
jg 0x283b
movl 0x10(%r12), %eax
movq -0x38(%rbp), %rcx
movl %eax, (%rcx)
cmpb $0x0, -0x2c(%rbp)
je 0x2827
movq 0x18(%r12), %r13
decq 0x10(%r14)
movq %r13, %rdi
callq 0x21e0
movq %r13, %rdi
callq 0x2130
movq (%r14), %r13
movl $0x18, %edi
callq 0x2170
movl (%r15), %ecx
movl %ecx, 0x10(%rax)
movq %rax, %rdi
movq %r13, %rsi
callq 0x2040
incq 0x10(%r14)
movq (%r14), %rax
movq %rax, 0x18(%r12)
movl 0x50(%r14), %r13d
jmp 0x283b
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x283b
movl $0xfffffffd, %r13d      # imm = 0xFFFFFFFD
movq %rbx, %rdi
callq 0x20e0
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x20c0
jmp 0x285e
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/raytracer.cpp
// Function: parseArgs(float*, std::__cxx11::basic_istringstream<char, std::char_traits<char>, std::allocator<char>>*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void parseArgs(float args[], istringstream *iss, int numArgs, string errMessage) {
    string temp;
    int index = 0;
    while (*iss >> temp){
        args[index] = atof(temp.c_str());
        index++;
    }

    if (index != numArgs){
        cerr << errMessage << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x50(%rbp)
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %ebx, %ebx
leaq -0x48(%rbp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x32c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x398d
movq -0x48(%rbp), %rdi
callq 0x32a0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%r12,%rbx,4)
incq %rbx
jmp 0x395c
cmpl %ebx, %r14d
je 0x39d3
movq -0x50(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x1a64c(%rip), %rdi     # 0x1dff0
callq 0x3260
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3170
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x39ec
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3220
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39fd
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3a19
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/raytracer.cpp
// Function: parseArgs(int*, std::__cxx11::basic_istringstream<char, std::char_traits<char>, std::allocator<char>>*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void parseArgs(int args[], istringstream *iss, int numArgs, string errMessage) {
    string temp;
    int index = 0;
    while (*iss >> temp){
        args[index] = atoi(temp.c_str());
        index++;
    }

    if (index != numArgs){
        cerr << errMessage << endl;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x50(%rbp)
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %ebx, %ebx
leaq -0x48(%rbp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x32c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3a83
movq -0x48(%rbp), %rdi
callq 0x33b0
movl %eax, (%r12,%rbx,4)
incq %rbx
jmp 0x3a58
cmpl %ebx, %r14d
je 0x3ac9
movq -0x50(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x1a556(%rip), %rdi     # 0x1dff0
callq 0x3260
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3170
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3ae2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3220
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3af3
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3b0f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/raytracer.cpp
// Function: Film::Film(int, int)
Film(int _width, int _height) {
    	width = _width;
    	height = _height;
        for (int i = 0; i < width * height; i++) {
        	film.push_back(vec3(0, 0, 0));
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
imull %esi, %edx
testl %edx, %edx
jle 0x6e66
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
xorl %r12d, %r12d
leaq -0x40(%rbp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x9ebe
incl %r12d
movl 0x4(%rbx), %eax
imull (%rbx), %eax
cmpl %eax, %r12d
jl 0x6e3e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x6e8a
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x3220
movq %r15, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/./algebra3.h
// Function: rotation3D(vec3, double)
inline mat4 rotation3D(vec3 Axis, const double angleDeg) {
    double  angleRad = angleDeg * M_PI / 180.0,
	    c = cos(angleRad),
	    s = sin(angleRad),
	    t = 1.0 - c;

    Axis.normalize();
    return mat4(vec4(t * Axis[VX] * Axis[VX] + c,
		     t * Axis[VX] * Axis[VY] - s * Axis[VZ],
		     t * Axis[VX] * Axis[VZ] + s * Axis[VY],
		     0.0),
		vec4(t * Axis[VX] * Axis[VY] + s * Axis[VZ],
		     t * Axis[VY] * Axis[VY] + c,
		     t * Axis[VY] * Axis[VZ] - s * Axis[VX],
		     0.0),
		vec4(t * Axis[VX] * Axis[VZ] - s * Axis[VY],
		     t * Axis[VY] * Axis[VZ] + s * Axis[VX],
		     t * Axis[VZ] * Axis[VZ] + c,
		     0.0),
		vec4(0.0, 0.0, 0.0, 1.0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
mulsd 0xffff(%rip), %xmm0     # 0x17018
divsd 0xffff(%rip), %xmm0     # 0x17020
movsd %xmm0, -0x18(%rbp)
callq 0x34a0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x3080
movsd 0xffce(%rip), %xmm4     # 0x17010
movapd %xmm4, %xmm1
movsd -0x20(%rbp), %xmm12
subsd %xmm12, %xmm1
movsd (%r14), %xmm2
movsd 0x8(%r14), %xmm3
movapd %xmm3, %xmm5
mulsd %xmm3, %xmm5
movapd %xmm2, %xmm6
mulsd %xmm2, %xmm6
addsd %xmm5, %xmm6
movsd 0x10(%r14), %xmm5
movapd %xmm5, %xmm7
mulsd %xmm5, %xmm7
addsd %xmm6, %xmm7
xorps %xmm6, %xmm6
sqrtsd %xmm7, %xmm6
divsd %xmm6, %xmm4
mulsd %xmm4, %xmm2
movsd %xmm2, (%r14)
mulsd %xmm4, %xmm3
movsd %xmm3, 0x8(%r14)
mulsd %xmm5, %xmm4
movsd %xmm4, 0x10(%r14)
movapd %xmm1, %xmm5
mulsd %xmm2, %xmm5
movapd %xmm5, %xmm6
mulsd %xmm2, %xmm6
addsd %xmm12, %xmm6
movapd %xmm5, %xmm8
mulsd %xmm3, %xmm8
movapd %xmm0, %xmm7
mulsd %xmm0, %xmm2
mulsd %xmm4, %xmm0
movapd %xmm8, %xmm9
subsd %xmm0, %xmm9
mulsd %xmm3, %xmm7
mulsd %xmm4, %xmm5
movapd %xmm5, %xmm10
addsd %xmm7, %xmm10
addsd %xmm8, %xmm0
movapd %xmm1, %xmm8
mulsd %xmm3, %xmm8
mulsd %xmm8, %xmm3
addsd %xmm12, %xmm3
mulsd %xmm4, %xmm8
movapd %xmm8, %xmm11
subsd %xmm2, %xmm11
subsd %xmm7, %xmm5
addsd %xmm8, %xmm2
mulsd %xmm4, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm12, %xmm1
movsd %xmm6, (%rbx)
movsd %xmm9, 0x8(%rbx)
movsd %xmm10, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movsd %xmm0, 0x20(%rbx)
movsd %xmm3, 0x28(%rbx)
movsd %xmm11, 0x30(%rbx)
movq %rax, 0x38(%rbx)
movsd %xmm5, 0x40(%rbx)
movsd %xmm2, 0x48(%rbx)
movsd %xmm1, 0x50(%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x68(%rbx)
movupd %xmm0, 0x58(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/raytracer.cpp
// Function: Scene::render()
void render() {
        Sampler sampler = Sampler(width, height);
        Sample sample = Sample();
        int count = 0;
        int tenthPixels = width * height / 10;
        while (sampler.generateSample(&sample)) {
            Ray testRay = cam.generateRay(sample);
            vec3 color = traceRay(testRay, maxDepth);
            film.writeToFilm(sample, color);
            if (count > tenthPixels) {
                cout << sampler.percentage() << "\% completed." << endl;
                count = 0;
            }
            count++;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl 0x108(%rdi), %eax
movq %rax, -0x48(%rbp)
movl 0x10c(%rdi), %eax
xorl %r12d, %r12d
movl %r12d, -0x2c(%rbp)
movl %r12d, -0x34(%rbp)
movl %eax, -0x30(%rbp)
testl %eax, %eax
je 0x737d
movq %rdi, %rbx
movl -0x30(%rbp), %eax
movq -0x48(%rbp), %rdx
imull %edx, %eax
cltq
imulq $0x66666667, %rax, %rsi # imm = 0x66666667
movq %rsi, %rcx
shrq $0x3f, %rcx
sarq $0x22, %rsi
addl %ecx, %esi
movq %rsi, -0x58(%rbp)
leal -0x1(%rdx), %ecx
movl %ecx, -0x3c(%rbp)
leaq 0x80(%rdi), %rcx
movq %rcx, -0x60(%rbp)
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x38(%rbp)
xorl %r14d, %r14d
movl -0x2c(%rbp), %eax
movl %eax, -0x50(%rbp)
movl %r12d, -0x4c(%rbp)
leaq -0x2c(%rbp), %rcx
cmpl -0x3c(%rbp), %eax
jne 0x72b3
movl $0x0, -0x2c(%rbp)
movl %r12d, %eax
leaq -0x34(%rbp), %rcx
incl %eax
movl %eax, (%rcx)
leaq -0xb0(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
leaq -0x50(%rbp), %r13
movq %r13, %rdx
callq 0x8998
movl 0x110(%rbx), %ecx
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x8ac8
movq -0x60(%rbp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x8ffc
movl -0x34(%rbp), %r12d
cmpl -0x58(%rbp), %r14d
jle 0x7370
movl %r12d, %eax
imull -0x48(%rbp), %eax
addl -0x2c(%rbp), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss -0x38(%rbp), %xmm0
mulss 0xfd65(%rip), %xmm0     # 0x17084
cvttss2si %xmm0, %esi
movq 0x16ca6(%rip), %rdi     # 0x1dfd0
callq 0x3410
movq %rax, %r14
movl $0xc, %edx
movq %rax, %rdi
leaq 0x100f3(%rip), %rsi     # 0x17434
callq 0x3260
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x31e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3170
xorl %r14d, %r14d
incl %r14d
cmpl -0x30(%rbp), %r12d
jne 0x7292
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/raytracer.cpp
// Function: Film::writeToFilm(Sample&, vec3&)
void writeToFilm(Sample &sample, vec3 &fColor) {
    	vec3 color = floatToByte(fColor);
    	if (color[RED] > 255) {color[RED] = 255;}
    	if (color[GREEN] > 255) {color[GREEN] = 255;}
    	if (color[BLUE] > 255) {color[BLUE] = 255;}
        film.at(sample.y * width + sample.x)[RED] = color[RED];
        film.at(sample.y * width + sample.x)[GREEN] = color[GREEN];
        film.at(sample.y * width + sample.x)[BLUE] = color[BLUE];
    }

// Assembly:
movslq 0x4(%rsi), %rax
movslq (%rdi), %rcx
imulq %rax, %rcx
movslq (%rsi), %rsi
addq %rcx, %rsi
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdi
subq %rcx, %rdi
sarq $0x3, %rdi
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rax
cmpq %rsi, %rax
jbe 0x9093
movsd 0xdfd1(%rip), %xmm0     # 0x17008
movsd 0x10(%rdx), %xmm1
mulsd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
movapd %xmm0, %xmm2
movsd 0x8(%rdx), %xmm3
mulsd %xmm0, %xmm3
cvttpd2dq %xmm3, %xmm3
minsd %xmm1, %xmm2
cvtdq2pd %xmm3, %xmm1
movapd %xmm0, %xmm3
movsd (%rdx), %xmm4
mulsd %xmm0, %xmm4
cvttpd2dq %xmm4, %xmm4
minsd %xmm1, %xmm3
cvtdq2pd %xmm4, %xmm1
minsd %xmm1, %xmm0
leaq (%rsi,%rsi,2), %rax
movsd %xmm0, (%rcx,%rax,8)
movsd %xmm3, 0x8(%rcx,%rax,8)
movsd %xmm2, 0x10(%rcx,%rax,8)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xe3a3(%rip), %rdi      # 0x17441
movq %rax, %rdx
xorl %eax, %eax
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/raytracer.cpp
// Function: Light::intensityAt(vec3&)
vec3 intensityAt(vec3 &point) {
        if (falloff == 0) {
        	return color;
        } else {
        	float d = distance(pos, point);
            return color / pow(d, falloff);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x30(%rsi), %eax
testl %eax, %eax
je 0x988b
movsd 0x18(%r14), %xmm0
movsd 0x20(%r14), %xmm1
subsd (%rdx), %xmm0
mulsd %xmm0, %xmm0
subsd 0x8(%rdx), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x28(%r14), %xmm0
subsd 0x10(%rdx), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
callq 0x3440
movsd 0xd7a4(%rip), %xmm1     # 0x17010
divsd %xmm0, %xmm1
movsd (%r14), %xmm0
mulsd %xmm1, %xmm0
movsd 0x8(%r14), %xmm2
mulsd %xmm1, %xmm2
mulsd 0x10(%r14), %xmm1
jmp 0x989c
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm2
movsd 0x10(%r14), %xmm1
movsd %xmm0, (%rbx)
movsd %xmm2, 0x8(%rbx)
movsd %xmm1, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/lodepng.cpp
// Function: append_symbol_coins(Coin*, unsigned int const*, unsigned int, unsigned long)
static unsigned append_symbol_coins(Coin* coins, const unsigned* frequencies, unsigned numcodes, size_t sum)
{
  unsigned i;
  unsigned j = 0; /*index of present symbols*/
  for(i = 0; i != numcodes; ++i)
  {
    if(frequencies[i] != 0) /*only include symbols that are present*/
    {
      coins[j].weight = frequencies[i] / (float)sum;
      uivector_push_back(&coins[j].symbols, i);
      ++j;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
testl %edx, %edx
je 0xae00
movq %rdi, %r14
testq %rcx, %rcx
js 0xad88
cvtsi2ss %rcx, %xmm0
jmp 0xad9d
movq %rcx, %rax
shrq %rax
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movl %edx, %r12d
xorl %r13d, %r13d
xorl %ebx, %ebx
movq -0x38(%rbp), %rax
movl (%rax,%r13,4), %eax
testl %eax, %eax
je 0xadf8
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
divss -0x2c(%rbp), %xmm0
movl %ebx, %eax
shlq $0x5, %rax
leaq (%r14,%rax), %r15
movss %xmm0, 0x18(%r14,%rax)
movq 0x8(%r14,%rax), %rsi
incq %rsi
movq %r15, %rdi
callq 0x13f07
testl %eax, %eax
je 0xadf6
movq (%r15), %rax
movq 0x8(%r15), %rcx
movl %r13d, -0x4(%rax,%rcx,4)
incl %ebx
incq %r13
cmpq %r13, %r12
jne 0xadaa
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng_crc32(unsigned char const*, unsigned long)
unsigned lodepng_crc32(const unsigned char* buf, size_t len)
{
  unsigned c = 0xffffffffL;
  size_t n;

  for(n = 0; n < len; ++n)
  {
    c = lodepng_crc32_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);
  }
  return c ^ 0xffffffffL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0xd5b0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
leaq 0xa12e(%rip), %rdx      # 0x176c0
movb (%rdi,%rcx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rdx,%r8,4), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0xd592
notl %eax
jmp 0xd5b2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng_has_palette_alpha(LodePNGColorMode const*)
unsigned lodepng_has_palette_alpha(const LodePNGColorMode* info)
{
  size_t i;
  for(i = 0; i != info->palettesize; ++i)
  {
    if(info->palette[i * 4 + 3] < 255) return 1;
  }
  return 0;
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xdb26
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rcx
xorl %edx, %edx
cmpb $-0x1, 0x3(%rcx,%rdx,4)
jne 0xdb29
incq %rdx
cmpq %rdx, %rax
jne 0xdb13
xorl %eax, %eax
jmp 0xdb2e
xorl %eax, %eax
retq
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng_color_mode_equal(LodePNGColorMode const*, LodePNGColorMode const*)
static int lodepng_color_mode_equal(const LodePNGColorMode* a, const LodePNGColorMode* b)
{
  size_t i;
  if(a->colortype != b->colortype) return 0;
  if(a->bitdepth != b->bitdepth) return 0;
  if(a->key_defined != b->key_defined) return 0;
  if(a->key_defined)
  {
    if(a->key_r != b->key_r) return 0;
    if(a->key_g != b->key_g) return 0;
    if(a->key_b != b->key_b) return 0;
  }
  if(a->palettesize != b->palettesize) return 0;
  for(i = 0; i != a->palettesize * 4; ++i)
  {
    if(a->palette[i] != b->palette[i]) return 0;
  }
  return 1;
}

// Assembly:
movl (%rdi), %ecx
xorl %eax, %eax
cmpl (%rsi), %ecx
jne 0xe7b8
movl 0x4(%rdi), %ecx
cmpl 0x4(%rsi), %ecx
jne 0xe7b8
movl 0x18(%rdi), %ecx
cmpl 0x18(%rsi), %ecx
jne 0xe7b8
testl %ecx, %ecx
je 0xe77b
movl 0x1c(%rdi), %ecx
cmpl 0x1c(%rsi), %ecx
jne 0xe7b8
movl 0x20(%rdi), %ecx
cmpl 0x20(%rsi), %ecx
jne 0xe7b8
movl 0x24(%rdi), %ecx
cmpl 0x24(%rsi), %ecx
jne 0xe7b8
movq 0x10(%rdi), %rcx
cmpq 0x10(%rsi), %rcx
jne 0xe7b8
shlq $0x2, %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0xe7b8
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rdx
movq 0x8(%rsi), %rsi
xorl %edi, %edi
movb (%rdx,%rdi), %r8b
cmpb (%rsi,%rdi), %r8b
jne 0xe7b5
incq %rdi
cmpq %rdi, %rcx
jne 0xe7a1
jmp 0xe7b7
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng_state_init(LodePNGState*)
void lodepng_state_init(LodePNGState* state)
{
#ifdef LODEPNG_COMPILE_DECODER
  lodepng_decoder_settings_init(&state->decoder);
#endif /*LODEPNG_COMPILE_DECODER*/
#ifdef LODEPNG_COMPILE_ENCODER
  lodepng_encoder_settings_init(&state->encoder);
#endif /*LODEPNG_COMPILE_ENCODER*/
  lodepng_color_mode_init(&state->info_raw);
  lodepng_info_init(&state->info_png);
  state->error = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movaps 0x6787(%rip), %xmm0     # 0x17530
movups %xmm0, 0x2c(%rdi)
xorl %eax, %eax
movl %eax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x1c(%rdi)
movaps 0x677c(%rip), %xmm1     # 0x17540
movups %xmm1, 0x3c(%rdi)
movl $0x1, %ecx
movl %ecx, 0x4c(%rdi)
movups %xmm0, 0x50(%rdi)
movq %rax, 0x60(%rdi)
movl %ecx, 0x70(%rdi)
movabsq $0x100000001, %rdx      # imm = 0x100000001
movq %rdx, 0x68(%rdi)
movups %xmm0, 0x78(%rdi)
movl %ecx, 0x88(%rdi)
movups %xmm0, 0xa8(%rdi)
movabsq $0x800000006, %rdx      # imm = 0x800000006
movq %rdx, 0x90(%rdi)
movups %xmm0, 0x98(%rdi)
movups %xmm0, 0xe0(%rdi)
movq %rdx, 0xc8(%rdi)
movups %xmm0, 0xd0(%rdi)
movl %eax, 0xc0(%rdi)
movq %rax, 0xb8(%rdi)
movl %eax, 0x15c(%rdi)
movups %xmm0, 0x190(%rdi)
movups %xmm0, 0x180(%rdi)
movups %xmm0, 0x170(%rdi)
movl %eax, 0x140(%rdi)
movups %xmm0, 0x130(%rdi)
movups %xmm0, 0x120(%rdi)
movups %xmm0, 0x110(%rdi)
movups %xmm0, 0x100(%rdi)
movups %xmm0, 0xf0(%rdi)
movl %ecx, 0x1a0(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng_encoder_settings_init(LodePNGEncoderSettings*)
void lodepng_encoder_settings_init(LodePNGEncoderSettings* settings)
{
  lodepng_compress_settings_init(&settings->zlibsettings);
  settings->filter_palette_zero = 1;
  settings->filter_strategy = LFS_MINSUM;
  settings->auto_convert = 1;
  settings->force_palette = 0;
  settings->predefined_filters = 0;
#ifdef LODEPNG_COMPILE_ANCILLARY_CHUNKS
  settings->add_id = 0;
  settings->text_compression = 1;
#endif /*LODEPNG_COMPILE_ANCILLARY_CHUNKS*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movaps 0x654c(%rip), %xmm0     # 0x17520
movups %xmm0, (%rdi)
movabsq $0x100000080, %rax      # imm = 0x100000080
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq $0x0, 0x28(%rdi)
movl $0x1, %eax
movl %eax, 0x38(%rdi)
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movl %eax, 0x50(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/lodepng.cpp
// Function: addChunk_tIME(ucvector*, LodePNGTime const*)
static unsigned addChunk_tIME(ucvector* out, const LodePNGTime* time)
{
  unsigned error = 0;
  unsigned char* data = (unsigned char*)lodepng_malloc(7);
  if(!data) return 83; /*alloc fail*/
  data[0] = (unsigned char)(time->year / 256);
  data[1] = (unsigned char)(time->year % 256);
  data[2] = (unsigned char)time->month;
  data[3] = (unsigned char)time->day;
  data[4] = (unsigned char)time->hour;
  data[5] = (unsigned char)time->minute;
  data[6] = (unsigned char)time->second;
  error = addChunk(out, "tIME", data, 7);
  lodepng_free(data);
  return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl $0x7, %edi
callq 0x32e0
testq %rax, %rax
je 0x12ac5
movq %rax, %r14
movzwl (%r15), %eax
rolw $0x8, %ax
movw %ax, (%r14)
movb 0x4(%r15), %al
movb %al, 0x2(%r14)
movb 0x8(%r15), %al
movb %al, 0x3(%r14)
movb 0xc(%r15), %al
movb %al, 0x4(%r14)
movb 0x10(%r15), %al
movb %al, 0x5(%r14)
movb 0x14(%r15), %al
movb %al, 0x6(%r14)
leaq 0x8(%rbx), %rsi
leaq 0x63b3(%rip), %rcx      # 0x18e4a
movq %rbx, %rdi
movl $0x7, %edx
movq %r14, %r8
callq 0xd813
testl %eax, %eax
jne 0x12ab3
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3280
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/logicx24[P]RayTracer/lodepng.cpp
// Function: lodepng::load_file(std::vector<unsigned char, std::allocator<unsigned char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void load_file(std::vector<unsigned char>& buffer, const std::string& filename)
{
  std::ifstream file(filename.c_str(), std::ios::in|std::ios::binary|std::ios::ate);

  /*get filesize*/
  std::streamsize size = 0;
  if(file.seekg(0, std::ios::end).good()) size = file.tellg();
  if(file.seekg(0, std::ios::beg).good()) size -= file.tellg();

  /*read contents of the file into the vector*/
  buffer.resize(size_t(size));
  if(size > 0) file.read((char*)(&buffer[0]), size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x218(%rbp), %r14
movq %r14, %rdi
movl $0xe, %edx
callq 0x3480
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x32f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpl $0x0, 0x20(%rax,%rcx)
je 0x13646
xorl %r14d, %r14d
jmp 0x13655
leaq -0x218(%rbp), %rdi
callq 0x3420
movq %rax, %r14
leaq -0x218(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x32f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpl $0x0, 0x20(%rax,%rcx)
jne 0x13682
leaq -0x218(%rbp), %rdi
callq 0x3420
subq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x164c2
testq %r14, %r14
jle 0x136a4
movq (%rbx), %rsi
leaq -0x218(%rbp), %rdi
movq %r14, %rdx
callq 0x32b0
leaq -0x218(%rbp), %rdi
callq 0x30b0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x136c0
jmp 0x136c0
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/superblocks[P]superblocks/set-spt.cpp
// Function: Superblocks::init()
void Superblocks::init() {

	coin = "SPT"; 
	coin_name = "Spots";

	hash_length = 64;

	// normal (step 0)
	reward[0] = 49;

	// superblock (step 1)
	reward[1] = 10045; // superblock reward (step 1)
	seed_type[1] = SEED_WITH_PREVIOUS_BLOCK_HASH;
	cutout_start[1] = 8;
	cutout_length[1] = 7;
	rnd_range_low[1] = 1;
	rnd_range_high[1] = 100000;
	luck_type[1] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[1] = 50000;
	luck_y[1] = 50011;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x18, %rdi
movq 0x20(%rbx), %rdx
leaq 0x18f4(%rip), %rcx      # 0x3b00
movl $0x3, %r8d
xorl %esi, %esi
callq 0x1130
leaq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rdx
leaq 0x18dc(%rip), %rcx      # 0x3b04
movl $0x5, %r8d
xorl %esi, %esi
callq 0x1130
movl $0x40, 0x58(%rbx)
movl $0x273d, 0xd8(%rbx)     # imm = 0x273D
movl $0x2, 0x60(%rbx)
movl $0x8, 0x68(%rbx)
movl $0x7, 0x70(%rbx)
movl $0x1, 0x78(%rbx)
movl $0x186a0, 0x80(%rbx)    # imm = 0x186A0
movl $0x3, 0xc0(%rbx)
movl $0xc350, 0xc8(%rbx)     # imm = 0xC350
movabsq $0x310000c35b, %rax     # imm = 0x310000C35B
movq %rax, 0xd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/HQarroum[P]thread-pool/examples/working-with-tokens/main.cpp
// Function: main
int main() {
 thread::pool::pool_t pool(std::thread::hardware_concurrency() + 1);
 
 // Creating a producer token.
 auto producer_token = pool.create_token_of<thread::pool::producer_token_t>();

 // Filling our array with `iterations` amount of functions,
 // bound to the number `42`.
 std::fill_n(callables, iterations, std::bind(static_void_function, 42));
 // Scheduling the execution in bulk.
 auto result = pool.schedule_bulk(producer_token, callables, iterations);
 // Log whether the insertion was successful.
 std::cout << "The insertion has " << (result ? "succeeded." : "failed.") << std::endl;
 assert(result == true);
 return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2b0, %rsp            # imm = 0x2B0
callq 0x21d0
leal 0x1(%rax), %esi
leaq 0x18(%rsp), %rdi
callq 0x25f0
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x3e06
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, (%rsp)
je 0x24a9
movq %rsp, %rcx
movq %rcx, 0x18(%rax)
leaq -0x94(%rip), %rax       # 0x241c
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movl $0x2a, 0x8(%rbx)
xorl %r14d, %r14d
leaq 0x6cb7(%rip), %r15      # 0x9180
leaq (%r15,%r14), %rdi
movq %rbx, %rsi
callq 0x459c
addq $0x20, %r14
cmpq $0xc80, %r14            # imm = 0xC80
jne 0x24c9
leaq 0x6c97(%rip), %rdx      # 0x9180
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
movl $0x64, %ecx
callq 0x26b8
movl %eax, %ebx
movq 0x6acc(%rip), %rdi      # 0x8fd0
leaq 0x2bb5(%rip), %rsi      # 0x50c0
movl $0x12, %edx
callq 0x21a0
leaq 0x2bb7(%rip), %rax      # 0x50d3
leaq 0x2bbb(%rip), %rsi      # 0x50de
testb %bl, %bl
cmovneq %rax, %rsi
movzbl %bl, %eax
leaq (%rax,%rax,2), %rdx
addq $0x7, %rdx
movq 0x6a95(%rip), %r14      # 0x8fd0
movq %r14, %rdi
callq 0x21a0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq 0x6a6f(%rip), %rdi      # 0x8fd0
callq 0x2030
movq %rax, %rdi
callq 0x2110
testb %bl, %bl
je 0x25a0
movq (%rsp), %rax
testq %rax, %rax
je 0x2587
movq $0x0, 0x10(%rax)
movb $0x1, 0x8(%rax)
leaq 0x18(%rsp), %rdi
callq 0x26f8
xorl %eax, %eax
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2b3f(%rip), %rdi      # 0x50e6
leaq 0x2b47(%rip), %rsi      # 0x50f5
leaq 0x2b49(%rip), %rcx      # 0x50fe
movl $0x25, %edx
callq 0x2100
movq %rax, %rbx
jmp 0x25de
jmp 0x25c6
movq %rax, %rbx
movq (%rsp), %rax
testq %rax, %rax
je 0x25de
movq $0x0, 0x10(%rax)
movb $0x1, 0x8(%rax)
leaq 0x18(%rsp), %rdi
callq 0x26f8
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/ipatix[P]wav2agb/converter.cpp
// Function: dpcm_lookahead(int&, unsigned long&, double const*, unsigned long, int)
static void dpcm_lookahead(
        int& minimumError, size_t& minimumErrorIndex,
        const double *sampleBuf, const size_t lookahead, const int prevLevel)
{
    if (lookahead == 0) {
        minimumError = 0;
        return;
    }

    minimumError = std::numeric_limits<int>::max();
    minimumErrorIndex = dpcmLookupTable.size();

    for (size_t i = 0; i < dpcmLookupTable.size(); i++) {
        int newLevel = prevLevel + dpcmLookupTable[i];

        int recMinimumError;
        size_t recMinimumErrorIndex;

        // TODO apply dither noise
        int s = clamp(static_cast<int>(floor(sampleBuf[0] * 128.0)), -128, 127);
        int errorEstimation = squared(s - newLevel);
        if (errorEstimation >= minimumError)
            continue;

        dpcm_lookahead(recMinimumError, recMinimumErrorIndex,
                sampleBuf + 1, lookahead - 1, newLevel);

        // TODO weigh the error squared
        int error = squared(s - newLevel) + recMinimumError;
        if (error < minimumError) {
            if (newLevel <= 127 && newLevel >= -128) {
                minimumError = error;
                minimumErrorIndex = i;
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
je 0x3055
movq %rdi, 0x18(%rsp)
movl $0x7fffffff, (%rdi)     # imm = 0x7FFFFFFF
movq 0x62d7(%rip), %r12      # 0x9248
movq 0x62c8(%rip), %rax      # 0x9240
movq %rax, 0x28(%rsp)
subq %rax, %r12
movq %rsi, 0x10(%rsp)
movq %r12, (%rsi)
je 0x305b
movq %rdx, %rbx
movsd (%rdx), %xmm0
mulsd 0x307b(%rip), %xmm0     # 0x6018
movl %r8d, (%rsp)
callq 0x2380
movl (%rsp), %ecx
movsd 0x306f(%rip), %xmm1     # 0x6020
maxsd %xmm0, %xmm1
movsd 0x306b(%rip), %xmm0     # 0x6028
minsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movsbl %al, %r13d
addq $0x8, %rbx
movq %rbx, 0x20(%rsp)
decq 0x8(%rsp)
cmpq $0x1, %r12
adcq $0x0, %r12
movl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %r14d, %r14d
movq 0x28(%rsp), %rax
movsbl (%rax,%r14), %ebp
addl %ecx, %ebp
movl %r13d, %r15d
subl %ebp, %r15d
imull %r15d, %r15d
cmpl %ebx, %r15d
jge 0x304b
leaq 0x4(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl %ebp, %r8d
callq 0x2f43
movsbl %bpl, %eax
cmpl %ebp, %eax
jne 0x3048
addl 0x4(%rsp), %r15d
cmpl %ebx, %r15d
movl (%rsp), %ecx
jge 0x304b
movq 0x18(%rsp), %rax
movl %r15d, (%rax)
movq 0x10(%rsp), %rax
movq %r14, (%rax)
movl %r15d, %ebx
jmp 0x304b
movl (%rsp), %ecx
incq %r14
cmpq %r14, %r12
jne 0x2fe7
jmp 0x305b
movl $0x0, (%rdi)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ipatix[P]wav2agb/wav2agb.cpp
// Function: die(char const*, ...)
static void die(const char *msg, ...) {
    va_list args;
    va_start(args, msg);
    vfprintf(stderr, msg, args);
    va_end(args);
    exit(1);
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x3aeb
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0x54c6(%rip), %rax      # 0x8fd8
movq (%rax), %rdi
movq %r10, %rsi
callq 0x22c0
movl $0x1, %edi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/ipatix[P]wav2agb/wav2agb.cpp
// Function: filename_without_ext(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string filename_without_ext(const std::string& str) {
    size_t last_path_seperator = 0;
    char *sep = path_seperators;
    while (*sep) {
        size_t pos = str.find_last_of(*sep);
        if (pos != std::string::npos)
            last_path_seperator = std::max(pos, last_path_seperator);
        sep += 1;
    }
    size_t file_ext_dot_pos = str.find_last_of('.');
    if (file_ext_dot_pos == std::string::npos)
        return std::string(str);
    assert(file_ext_dot_pos != last_path_seperator);
    if (file_ext_dot_pos > last_path_seperator)
        return str.substr(0, file_ext_dot_pos);
    return std::string(str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x2410
xorl %r15d, %r15d
cmpq $-0x1, %rax
cmovneq %rax, %r15
movq %r14, %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x2410
cmpq $-0x1, %rax
je 0x3be8
cmpq %r15, %rax
je 0x3c06
jbe 0x3be8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x2230
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3d80
leaq 0x29ca(%rip), %rdi      # 0x65d7
leaq 0x29eb(%rip), %rsi      # 0x65ff
leaq 0x29f0(%rip), %rcx      # 0x660b
movl $0x4a, %edx
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O3/brunokeymolen[P]ssdp/src/tools.cpp
// Function: caseinstringcmp(unsigned char*, unsigned int, unsigned char*, unsigned int)
int caseinstringcmp(u8* string1, u32 len1, u8* string2, u32 len2){
    u8 ret = 0;

    if(len1 == len2){
        for(int tel=0;tel<(int)len1;tel++){
            if( (string1[tel] >= 'A' && string1[tel]<='Z') || (string1[tel] >= 'a' && string1[tel]<='z') ){
                if( (string1[tel] == string2[tel]) || (string1[tel]+32 == string2[tel]) || (string1[tel]-32 == string2[tel]) ){
                    //equal
                }else{
                    if(string1[tel] > string2[tel]){
                        ret = 1;
                    }else if(string1[tel] < string2[tel]){
                        ret = -1;
                    }
                }
            }else{
                if(string1[tel] > string2[tel]){
                    ret = 1;
                }else if(string1[tel] < string2[tel]){
                    ret = -1;
                }
            }
            if(ret != 0){
                break;
            }
        }
    }else{
        ret = -1;
    }

    return ret;
}

// Assembly:
movl $0xff, %eax
cmpl %ecx, %esi
jne 0x386a
testl %esi, %esi
jle 0x3868
movl %esi, %ecx
xorl %esi, %esi
movzbl (%rdi,%rsi), %r8d
movl %r8d, %r9d
andb $-0x21, %r9b
addb $-0x41, %r9b
cmpb $0x19, %r9b
ja 0x3852
movb (%rdx,%rsi), %r9b
cmpb %r9b, %r8b
je 0x3860
movzbl %r9b, %r10d
leal 0x20(%r8), %r11d
cmpl %r10d, %r11d
je 0x3860
leal -0x20(%r8), %r11d
cmpl %r10d, %r11d
jne 0x3856
jmp 0x3860
movb (%rdx,%rsi), %r9b
cmpb %r9b, %r8b
ja 0x386b
cmpb %r9b, %r8b
jb 0x386a
incq %rsi
cmpq %rsi, %rcx
jne 0x381b
xorl %eax, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/brunokeymolen[P]ssdp/src/tools.cpp
// Function: trimspaces(unsigned char**, unsigned int*)
void trimspaces(u8** buf, u32* len){
    u8 *b = *buf;
    u32 l = *len;
    //left
    b = lefttrim(*buf, *len);
    l = (int)(l - (b - *buf));
    //right
    l = righttrim(b, l);

    *buf = b;
    *len = l;
}

// Assembly:
movl (%rsi), %ecx
movq (%rdi), %rdx
movq %rdx, %rax
testq %rcx, %rcx
je 0x3892
leaq (%rdx,%rcx), %r8
movq %rdx, %rax
cmpb $0x20, (%rax)
jne 0x3892
incq %rax
cmpq %r8, %rax
jbe 0x3885
subl %eax, %edx
addl %ecx, %edx
je 0x38b7
movl %edx, %r8d
leaq -0x1(%rax), %rdx
movq %r8, %rcx
leaq (%rdx,%r8), %r9
cmpq %rax, %r9
jb 0x38b9
leaq -0x1(%rcx), %r8
cmpb $0x20, (%r9)
je 0x389f
jmp 0x38b9
xorl %ecx, %ecx
movq %rax, (%rdi)
movl %ecx, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/brunokeymolen[P]ssdp/src/tools.cpp
// Function: getchar(unsigned char*, unsigned int, char)
int getchar(u8* buf, u32 len, char c){
    int ret = -1;
    for(int x=0;x<(int)len;x++){
        if(buf[x]==c){
            ret=x;
            break;
        }
    }
    return ret;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %esi, %esi
jle 0x38e1
movsbl %dl, %ecx
movl %esi, %esi
xorl %edx, %edx
movzbl (%rdi,%rdx), %r8d
cmpl %ecx, %r8d
je 0x38e2
incq %rdx
cmpq %rdx, %rsi
jne 0x38cf
retq
movl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/brunokeymolen[P]ssdp/src/tools.cpp
// Function: getchar(unsigned char*, unsigned int, char, int)
int getchar(u8* buf, u32 len, char c, int seq){
    int ret = -1;
    int found=0;
    for(int x=0;x<(int)len;x++){
        if(buf[x]==c){
            found++;
            if(found==seq){
                ret=x;
                break;
            }
        }
    }
    return ret;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %esi, %esi
jle 0x3913
movsbl %dl, %edx
movl %esi, %r8d
xorl %esi, %esi
xorl %r9d, %r9d
movzbl (%rdi,%rsi), %r10d
cmpl %edx, %r10d
jne 0x390b
incl %r9d
cmpl %ecx, %r9d
je 0x3914
incq %rsi
cmpq %rsi, %r8
jne 0x38f9
retq
movl %esi, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/brunokeymolen[P]ssdp/src/ssdp.cpp
// Function: SSDP::~SSDP()
SSDP::~SSDP(){
    Stop();
    delete(mParser);
    mParser = NULL;
    mDB->Stop();
    delete(mDB);
    mDB = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7e8a(%rip), %rax      # 0xb908
movq %rax, (%rdi)
callq 0x3b52
movq 0x240(%rbx), %r14
testq %r14, %r14
je 0x3a9a
movq %r14, %rdi
callq 0x69a0
movl $0x40, %esi
movq %r14, %rdi
callq 0x3280
movq $0x0, 0x240(%rbx)
movq 0x248(%rbx), %rdi
callq 0x4f2c
movq 0x248(%rbx), %r14
testq %r14, %r14
je 0x3ad2
movq %r14, %rdi
callq 0x4e1e
movl $0x70, %esi
movq %r14, %rdi
callq 0x3280
movq $0x0, 0x248(%rbx)
movq 0x220(%rbx), %rdi
leaq 0x230(%rbx), %rax
cmpq %rax, %rdi
je 0x3b08
movq (%rax), %rsi
incq %rsi
callq 0x3280
movq 0x200(%rbx), %rdi
leaq 0x210(%rbx), %rax
cmpq %rax, %rdi
je 0x3b26
movq (%rax), %rsi
incq %rsi
callq 0x3280
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x3b42
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3280
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x4b44
// File: /workspace/github_cpp_makefile_star2_O3/brunokeymolen[P]ssdp/src/ssdp.cpp
// Function: SSDP::Stop()
int SSDP::Stop(){
    mReadLoop = 0;
    //@TODO: leave multicast groups
    if (mMulticastSocket > 0) {
        close(mMulticastSocket);
        mMulticastSocket = INVALID_SOCKET;
        close(mUnicastSocket);
        mUnicastSocket = INVALID_SOCKET;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x68(%rdi)
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x3b7b
callq 0x3450
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, 0x8(%rbx)
movl 0xc(%rbx), %edi
callq 0x3450
movl %ebp, 0xc(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/brunokeymolen[P]ssdp/src/ssdp.cpp
// Function: SSDP::NotifyAlive()
int SSDP::NotifyAlive(){
    const char *os=mOS.c_str();
    const char *product=mProduct.c_str();

    char buf[20048];

    sprintf(buf, "NOTIFY * HTTP/1.1\r\nHOST: 239.255.255.250:1900\r\nCACHE-CONTROL: max-age=100\r\nNT: upnp:rootdevice\r\nNTS: ssdp:alive\r\nSERVER: %s/14.0.0, %s, UPnP/1.1\r\nX-User-Agent: fkuehne-upnpx\r\n\r\n", os, product);

    if(mMulticastSocket != INVALID_SOCKET)
        sendto(mMulticastSocket, buf, strlen(buf), 0, (struct sockaddr*)&mDstaddr , sizeof(struct sockaddr));
    else
        printf("invalid socket\n");

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x4e50, %rsp           # imm = 0x4E50
movq %rdi, %rbx
movq 0x200(%rdi), %rdx
movq 0x220(%rdi), %rcx
leaq 0x3de0(%rip), %rsi      # 0x80f5
movq %rsp, %rdi
xorl %eax, %eax
callq 0x3090
movl 0x8(%rbx), %ebp
cmpl $-0x1, %ebp
je 0x4350
movq %rsp, %r14
movq %r14, %rdi
callq 0x3100
addq $0x20, %rbx
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
movl $0x10, %r9d
callq 0x3070
jmp 0x435c
leaq 0x405e(%rip), %rdi      # 0x83b5
callq 0x3380
xorl %eax, %eax
addq $0x4e50, %rsp           # imm = 0x4E50
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/brunokeymolen[P]ssdp/src/ssdp.cpp
// Function: SSDP::NotifyByeBye()
int SSDP::NotifyByeBye(){
    const char *os=mOS.c_str();
    const char *product=mProduct.c_str();

    char buf[20048];

    sprintf(buf, "NOTIFY * HTTP/1.1\r\nHOST: 239.255.255.250:1900\r\nCACHE-CONTROL: max-age=100\r\nNT: upnp:rootdevice\r\nNTS: ssdp:byebye\r\nSERVER: %s, %s, UPnP/1.1\r\nX-User-Agent: fkuehne-upnpx\r\n\r\n", os, product);

    if(mMulticastSocket != INVALID_SOCKET)
        sendto(mMulticastSocket, buf, strlen(buf), 0, (struct sockaddr*)&mDstaddr , sizeof(struct sockaddr));
    else
        printf("invalid socket\n");

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x4e50, %rsp           # imm = 0x4E50
movq %rdi, %rbx
movq 0x200(%rdi), %rdx
movq 0x220(%rdi), %rcx
leaq 0x3e1a(%rip), %rsi      # 0x81a7
movq %rsp, %rdi
xorl %eax, %eax
callq 0x3090
movl 0x8(%rbx), %ebp
cmpl $-0x1, %ebp
je 0x43c8
movq %rsp, %r14
movq %r14, %rdi
callq 0x3100
addq $0x20, %rbx
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
movl $0x10, %r9d
callq 0x3070
jmp 0x43d4
leaq 0x3fe6(%rip), %rdi      # 0x83b5
callq 0x3380
xorl %eax, %eax
addq $0x4e50, %rsp           # imm = 0x4E50
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/brunokeymolen[P]ssdp/src/ssdp.cpp
// Function: SSDP::RemoveObserver(SSDPObserver*)
int SSDP::RemoveObserver(SSDPObserver* observer){
    u8 found = 0;
    int tel = 0;
    std::vector<SSDPObserver*>::iterator it;
    for(it=mObservers.begin();it<mObservers.end();it++){
        if(observer == *it){
            //Remove this one and stop
            found = 1;
            break;
        }
        tel++;
    }
    if(found){
        mObservers.erase(mObservers.begin()+tel);
    }
    return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
movq 0x58(%rbx), %rax
cmpq %rax, %rdi
jae 0x475f
movq %rax, %rdx
subq %rdi, %rdx
addq $-0x8, %rdx
cmpq %rsi, (%rdi)
je 0x4745
addq $0x8, %rdi
addq $-0x8, %rdx
cmpq %rax, %rdi
jb 0x4731
jmp 0x475f
leaq 0x8(%rdi), %rsi
cmpq %rax, %rsi
je 0x4757
callq 0x33c0
movq 0x58(%rbx), %rax
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/brunokeymolen[P]ssdp/src/ssdp.cpp
// Function: SSDP::IncommingMessage(sockaddr*, unsigned char*, unsigned int)
int SSDP::IncommingMessage(struct sockaddr* sender, u8* buf, u32 len){
//    u8 *address;
    u16 port;

//    address = (u8*)sender->sa_data+2;
    memcpy(&port, sender->sa_data, 2);
    port = ntohs(port);

//    printf("receive from: %d.%d.%d.%d, port %d\n", address[0], address[1], address[2], address[3] , port);

    mParser->ReInit();
    mParser->Parse(sender, buf, len);

    //We have the type and all headers, check the mandatory headers for Advertisement & Search

    //Inform the observer(s)
    std::vector<SSDPObserver*>::const_iterator it;
    for(it=mObservers.begin();it<mObservers.end();it++){
        ((SSDPObserver*)*it)->SSDPMessage(mParser);
    }

    //hexdump(buf, len);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x240(%rdi), %rdi
callq 0x6a44
movq 0x240(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x6aa6
movq 0x50(%rbx), %r14
cmpq 0x58(%rbx), %r14
jae 0x4b2f
movq (%r14), %rdi
movq 0x240(%rbx), %rsi
movq (%rdi), %rax
callq *(%rax)
addq $0x8, %r14
jmp 0x4b14
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/brunokeymolen[P]ssdp/src/ssdpdb.cpp
// Function: SSDPDB::SSDPDB()
SSDPDB::SSDPDB(){
    int ret;

    ret = pthread_mutexattr_init(&mMutexAccessAttr);
    STAT(ret);
    ret = pthread_mutexattr_settype(&mMutexAccessAttr, PTHREAD_MUTEX_RECURSIVE);
    STAT(ret);
    ret = pthread_mutex_init(&mMutexAccess, &mMutexAccessAttr);
     STAT(ret);



EXIT:
    if(ret != 0){
        printf("SSDPDB Error\n");
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x30(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rbx, %rdi
callq 0x3060
testl %eax, %eax
je 0x4d7b
movl %eax, %ebp
callq 0x3040
movl (%rax), %ecx
leaq 0x36e9(%rip), %rax      # 0x8446
movq %rax, (%rsp)
leaq 0x3342(%rip), %rdi      # 0x80aa
leaq 0x36c8(%rip), %r9       # 0x8437
movl %ebp, %esi
xorl %edx, %edx
movl $0x2a, %r8d
jmp 0x4df9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3340
testl %eax, %eax
je 0x4dba
movl %eax, %ebp
callq 0x3040
movl (%rax), %ecx
leaq 0x36aa(%rip), %rax      # 0x8446
movq %rax, (%rsp)
leaq 0x3303(%rip), %rdi      # 0x80aa
leaq 0x3689(%rip), %r9       # 0x8437
movl %ebp, %esi
xorl %edx, %edx
movl $0x2c, %r8d
jmp 0x4df9
addq $0x38, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3360
testl %eax, %eax
je 0x4e14
movl %eax, %ebx
callq 0x3040
movl (%rax), %ecx
leaq 0x3669(%rip), %rax      # 0x8446
movq %rax, (%rsp)
leaq 0x32c2(%rip), %rdi      # 0x80aa
leaq 0x3648(%rip), %r9       # 0x8437
movl %ebx, %esi
xorl %edx, %edx
movl $0x2e, %r8d
xorl %eax, %eax
callq 0x3050
leaq 0x3646(%rip), %rdi      # 0x844d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x3380
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop