LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/shinerd[P]BriefRenderer/main.cpp
// Function: boundary_y(Vec2<int>, Vec2<int>, int)
int boundary_y(Vec2i v0, Vec2i v1, int x){
    float y;
    if (v1.x != v0.x){
        y = static_cast<float>(v1.y - v0.y) / (v1.x - v0.x) * (x - v0.x) + v0.y;
    }
    return static_cast<int>(y + 0.5);
}

// Assembly:
movq %rsi, %rax
shrq $0x20, %rax
subl %edi, %esi
movq %rdi, %rcx
shrq $0x20, %rcx
subl %ecx, %eax
cvtsi2ss %eax, %xmm0
subl %edi, %edx
cvtsi2ss %esi, %xmm1
divss %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %edx, %xmm1
mulss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2ss %ecx, %xmm0
addss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x2a89(%rip), %xmm0     # 0x5008
cvttsd2si %xmm0, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/shinerd[P]BriefRenderer/main.cpp
// Function: line(Vec2<int>, Vec2<int>, TGAImage&, TGAColor)
void line(Vec2i p0, Vec2i p1, TGAImage &image, TGAColor color) {
    bool steep = false;
    if (std::abs(p0.x-p1.x)<std::abs(p0.y-p1.y)) {
        std::swap(p0.x, p0.y);
        std::swap(p1.x, p1.y);
        steep = true;
    }
    if (p0.x>p1.x) {
        std::swap(p0, p1);
    }
    
    if (p0.x != p1.x) {
        for (int x=p0.x; x<=p1.x; x++) {
            float t = (x-p0.x)/(float)(p1.x-p0.x);
            int y = p0.y*(1.-t) + p1.y*t +0.5;
            if (steep) {
                image.set(y, x, color);
            } else {
                image.set(x, y, color);
            }
        }
    } else {
        for (int y=p0.y; y<=p1.y; y++) {
            image.set(p0.x, y, color);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdi, %rax
shrq $0x20, %rax
movq %rsi, %rcx
shrq $0x20, %rcx
movl %edi, %r8d
subl %esi, %r8d
movl %r8d, %r9d
negl %r9d
cmovsl %r8d, %r9d
movq %rdx, %r14
movl %eax, %edx
subl %ecx, %edx
movl %edx, %r13d
negl %r13d
cmovsl %edx, %r13d
movl %r9d, 0x14(%rsp)
cmpl %r13d, %r9d
jae 0x25d5
movl %edi, %r12d
movl %esi, %edx
jmp 0x25de
movl %eax, %r12d
movl %edi, %eax
movl %ecx, %edx
movl %esi, %ecx
cmpl %ecx, %eax
jle 0x25eb
movl %edx, %ebp
movl %ecx, %r15d
movl %eax, %edx
jmp 0x25f6
movl %r12d, %ebp
movl %eax, %r15d
movl %edx, %r12d
movl %ecx, %edx
cmpl %eax, %ecx
jne 0x2634
cmpl %r12d, %ebp
jg 0x26f6
incl %r12d
leaq 0x18(%rsp), %r13
movl (%rbx), %eax
movl %eax, 0x18(%rsp)
movl 0x4(%rbx), %eax
movl %eax, 0x1c(%rsp)
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %r13, %rcx
callq 0x43c8
incl %ebp
cmpl %ebp, %r12d
jne 0x260b
jmp 0x26f6
subl %r15d, %edx
jl 0x26f6
cvtsi2ss %edx, %xmm0
movss %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2ss %r12d, %xmm0
movss %xmm0, 0xc(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x30(%rsp)
incl %edx
movl %edx, %ebp
xorl %r12d, %r12d
leal (%r15,%r12), %edx
xorps %xmm0, %xmm0
cvtsi2ss %r12d, %xmm0
divss 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movsd 0x2986(%rip), %xmm2     # 0x5010
subsd %xmm1, %xmm2
mulsd 0x30(%rsp), %xmm2
mulss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm2, %xmm0
addsd 0x295e(%rip), %xmm0     # 0x5008
cvttsd2si %xmm0, %eax
movl (%rbx), %ecx
cmpl %r13d, 0x14(%rsp)
jae 0x26ce
movl %ecx, 0x28(%rsp)
movl 0x4(%rbx), %ecx
movl %ecx, 0x2c(%rsp)
movq %r14, %rdi
movl %eax, %esi
leaq 0x28(%rsp), %rcx
jmp 0x26e5
movl %ecx, 0x20(%rsp)
movl 0x4(%rbx), %ecx
movl %ecx, 0x24(%rsp)
movq %r14, %rdi
movl %edx, %esi
movl %eax, %edx
leaq 0x20(%rsp), %rcx
callq 0x43c8
incl %r12d
cmpl %r12d, %ebp
jne 0x2669
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/shinerd[P]BriefRenderer/tgaimage.cpp
// Function: TGAImage::TGAImage(TGAImage const&)
TGAImage::TGAImage(const TGAImage &img) {
    width = img.width;
    height = img.height;
    bytespp = img.bytespp;
    unsigned long nbytes = width*height*bytespp;
    data = new unsigned char[nbytes];
    memcpy(data, img.data, nbytes);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl 0xc(%rsi), %ecx
movl %ecx, 0xc(%rdi)
movl 0x10(%rsi), %edx
movl %edx, 0x10(%rdi)
imull %eax, %ecx
imull %edx, %ecx
movslq %ecx, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, (%r14)
movq (%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/shinerd[P]BriefRenderer/tgaimage.cpp
// Function: TGAImage::operator=(TGAImage const&)
TGAImage & TGAImage::operator =(const TGAImage &img) {
    if (this != &img) {
        if (data) delete [] data;
        width  = img.width;
        height = img.height;
        bytespp = img.bytespp;
        unsigned long nbytes = width*height*bytespp;
        data = new unsigned char[nbytes];
        memcpy(data, img.data, nbytes);
    }
    return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x3760
movq %rsi, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3729
callq 0x2200
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movl 0xc(%r14), %ecx
movl %ecx, 0xc(%rbx)
movl 0x10(%r14), %edx
movl %edx, 0x10(%rbx)
imull %eax, %ecx
imull %edx, %ecx
movslq %ecx, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, (%rbx)
movq (%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2170
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/shinerd[P]BriefRenderer/tgaimage.cpp
// Function: TGAImage::flip_vertically()
bool TGAImage::flip_vertically() {
    if (!data) return false;
    unsigned long bytes_per_line = width*bytespp;
    unsigned char *line = new unsigned char[bytes_per_line];
    int half = height>>1;
    for (int j=0; j<half; j++) {
        unsigned long l1 = j*bytes_per_line;
        unsigned long l2 = (height-1-j)*bytes_per_line;
        memmove((void *)line,      (void *)(data+l1), bytes_per_line);
        memmove((void *)(data+l1), (void *)(data+l2), bytes_per_line);
        memmove((void *)(data+l2), (void *)line,      bytes_per_line);
    }
    delete [] line;
    return true;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x3dda
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r13
movq %rax, 0x18(%rsp)
movslq 0x8(%rdi), %rax
movslq 0x10(%rdi), %r15
imulq %rax, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %rbp
movl 0xc(%r13), %eax
sarl %eax
testl %eax, %eax
jle 0x3dbf
movl %eax, %eax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %r14d, %r14d
movq %r15, 0x10(%rsp)
movq %r13, 0x8(%rsp)
movq %rax, 0x20(%rsp)
movl 0xc(%r13), %eax
addl %ebx, %eax
movslq %eax, %r12
imulq %r15, %r12
movq 0x8(%rsp), %rax
movq (%rax), %r13
leaq (%r14,%r13), %r15
movq %rbp, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
callq 0x2280
addq %r12, %r13
movq %r15, %rdi
movq %r13, %rsi
movq 0x8(%rsp), %r13
movq 0x10(%rsp), %r15
movq %r15, %rdx
callq 0x2280
addq (%r13), %r12
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x2280
movq 0x20(%rsp), %rax
addq %r15, %r14
decl %ebx
decq %rax
jne 0x3d55
movq %rbp, %rdi
callq 0x2200
movq 0x18(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
testq %rax, %rax
setne %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/shinerd[P]BriefRenderer/tgaimage.cpp
// Function: TGAImage::flip_horizontally()
bool TGAImage::flip_horizontally() {
    if (!data) return false;
    int half = width>>1;
    for (int i=0; i<half; i++) {
        for (int j=0; j<height; j++) {
            TGAColor c1 = get(i, j);
            TGAColor c2 = get(width-1-i, j);
            set(i, j, c2);
            set(width-1-i, j, c1);
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x3efb
movq %rdi, %rbx
movl 0x8(%rdi), %eax
sarl %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
jle 0x3efb
xorl %r13d, %r13d
leaq 0x30(%rsp), %r14
leaq 0x28(%rsp), %r15
cmpl $0x0, 0xc(%rbx)
jle 0x3eed
movl %r13d, %ebp
notl %ebp
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
movl %r13d, %edx
movl %r12d, %ecx
callq 0x435c
movl 0x8(%rbx), %edx
addl %ebp, %edx
movq %r15, %rdi
movq %rbx, %rsi
movl %r12d, %ecx
callq 0x435c
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3e96
movl 0x8(%rbx), %eax
cmpl %r13d, %eax
jle 0x3e96
cmpl %r12d, 0xc(%rbx)
jle 0x3e96
imull %r12d, %eax
addl %r13d, %eax
movslq 0x10(%rbx), %rdx
cltq
imulq %rdx, %rax
addq %rax, %rdi
leaq 0x20(%rsp), %rsi
callq 0x2170
movl 0x8(%rbx), %eax
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq (%rbx), %rdi
testq %rdi, %rdi
sete %dl
movl %eax, %ecx
addl %ebp, %ecx
sets %sil
orb %dl, %sil
jne 0x3ee0
cmpl %ecx, %eax
jle 0x3ee0
cmpl %r12d, 0xc(%rbx)
jle 0x3ee0
imull %r12d, %eax
addl %ecx, %eax
movslq 0x10(%rbx), %rdx
cltq
imulq %rdx, %rax
addq %rax, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2170
incl %r12d
cmpl 0xc(%rbx), %r12d
jl 0x3e34
incl %r13d
cmpl 0xc(%rsp), %r13d
jne 0x3e22
cmpq $0x0, 0x10(%rsp)
setne %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/shinerd[P]BriefRenderer/tgaimage.cpp
// Function: TGAImage::set(int, int, TGAColor)
bool TGAImage::set(int x, int y, TGAColor c) {
    if (!data || x<0 || y<0 || x>=width || y>=height) {
        return false;
    }
    memcpy(data+(x+y*width)*bytespp, c.raw, bytespp);
    return true;
}

// Assembly:
movq %rdi, %r8
movq (%rdi), %rdi
testq %rdi, %rdi
sete %al
movl %edx, %r9d
orl %esi, %r9d
sets %r9b
orb %al, %r9b
je 0x43e6
xorl %eax, %eax
retq
movl 0x8(%r8), %r9d
xorl %eax, %eax
cmpl %esi, %r9d
jle 0x43e5
cmpl %edx, 0xc(%r8)
jle 0x43e5
pushq %rax
imull %edx, %r9d
addl %esi, %r9d
movslq 0x10(%r8), %rdx
movslq %r9d, %rax
imulq %rdx, %rax
addq %rax, %rdi
movq %rcx, %rsi
callq 0x2170
movb $0x1, %al
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]asyncore_cpp/net/test/test_selector_impl.h
// Function: main
int main(){
	using MySelector = MySelector;
	using MyWorker   = MyWorker;

	int const fd1 = net::socket_create(net::socket_tcp,  "localhost.not.used.yet", 2000);
	int const fd2 = net::socket_create(net::socket_tcp,  "localhost.not.used.yet", 2002);
	int const fd3 = net::socket_create(net::socket_unix, "/tmp/echo");

	net::AsyncLoop<MySelector, MyWorker> loop( MySelector{ 4 }, MyWorker{}, { fd1, fd2, fd3 } );

	while(loop.process());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
leaq 0x1c97(%rip), %rbx      # 0x402c
movq %rbx, %rdi
movl $0x7d0, %esi            # imm = 0x7D0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x36fa
movl %eax, %r14d
movq %rbx, %rdi
movl $0x7d2, %esi            # imm = 0x7D2
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x36fa
movl %eax, %ebx
leaq 0x1c80(%rip), %rdi      # 0x4043
xorl %esi, %esi
movl $0x1, %edx
callq 0x3841
movl %eax, %r15d
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movl $0x4, %esi
callq 0x329c
leaq -0x4c(%rbp), %rax
movl %r14d, (%rax)
movl %ebx, 0x4(%rax)
movl %r15d, 0x8(%rax)
leaq -0x60(%rbp), %rcx
movq %rax, (%rcx)
movq $0x3, 0x8(%rcx)
leaq -0xd0(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movq %r12, %rsi
callq 0x2472
leaq -0x40(%rbp), %rdi
callq 0x3334
leaq -0xd0(%rbp), %rbx
movq %rbx, %rdi
callq 0x253a
testb %al, %al
jne 0x2423
leaq -0xd0(%rbp), %rdi
callq 0x2622
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3334
jmp 0x246a
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x2622
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::expireFD_()
void AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::expireFD_(){
	for(const auto &p : clients_){
		int const fd = p.first;
		auto &c = p.second;

		if (c.expired(CONN_TIMEOUT)){
			handleDisconnect_(fd, DisconnectStatus::TIMEOUT);
			// iterator is invalid now...
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x50(%rdi), %r14
leaq 0x40(%rdi), %r12
cmpq %r12, %r14
je 0x283f
movq %rdi, %rbx
movl 0x20(%r14), %r15d
movl 0x428(%r14), %r13d
addl $0x14, %r13d
callq 0x3620
cmpl %eax, %r13d
jb 0x284e
movq %r14, %rdi
callq 0x2140
movq %rax, %r14
cmpq %r12, %rax
jne 0x2816
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %r15d, %esi
movl $0x2, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a9c
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::handleRead_(int)
void AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::handleRead_(int const fd){
	if ( isServerFD_(fd) ){
		while (handleConnect_(fd));
		return;
	}

	// -------------------------------------

	auto it = clients_.find(fd);

	if (it == clients_.end())
		return handleDisconnect_(fd, DisconnectStatus::PROBLEM_MAP_NOT_FOUND);

	auto &buffer = it->second;

	// -------------------------------------

	auto available = buffer.capacity();

	if (available == 0){
		// buffer will overfow, disconnect.
		return handleDisconnect_(fd, DisconnectStatus::PROBLEM_BUFFER_READ);
	}

	ssize_t const size = ::read(fd, buffer.dataTail(), available);

	if (size <= 0)
		return handleSocketOps_(fd, size);

	buffer.push((size_t) size);

	buffer.restartTimer();

	handleWorker_(fd, buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq -0x2c(%rbp), %rdx
movl %esi, (%rdx)
movq 0x20(%rdi), %rdi
movq 0x28(%r14), %rsi
callq 0x2c02
cmpq 0x28(%r14), %rax
je 0x28ab
movq %r14, %rdi
movl %ebx, %esi
callq 0x2af0
testb %al, %al
jne 0x2898
jmp 0x297d
movq 0x48(%r14), %rdx
leaq 0x40(%r14), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x28d5
movq %rax, %rcx
xorl %esi, %esi
cmpl %ebx, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x28be
movq %rax, %r12
cmpq %rax, %rcx
je 0x28e7
cmpl %ebx, 0x20(%rcx)
cmovgq %rax, %rcx
movq %rcx, %r12
cmpq %rax, %r12
je 0x2906
movzwl 0x26(%r12), %eax
cmpq $0x400, %rax            # imm = 0x400
jne 0x2917
movq %r14, %rdi
movl %ebx, %esi
movl $0x6, %edx
jmp 0x2910
movq %r14, %rdi
movl %ebx, %esi
movl $0x5, %edx
callq 0x2a9c
jmp 0x297d
movl $0x400, %r13d           # imm = 0x400
movl $0x400, %edx            # imm = 0x400
subq %rax, %rdx
leaq (%r12,%rax), %rsi
addq $0x28, %rsi
movl %ebx, %edi
callq 0x21d0
testq %rax, %rax
jle 0x2970
leaq 0x24(%r12), %r15
movzwl 0x26(%r12), %ecx
subq %rcx, %r13
cmpq %rax, %r13
jb 0x2954
addl %eax, %ecx
movw %cx, 0x26(%r12)
callq 0x3620
movl %eax, 0x428(%r12)
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x2b8c
jmp 0x297d
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x2b40
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::handleWrite_(int)
void AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::handleWrite_(int const fd){
	if ( isServerFD_(fd) ){
		// WTF?!?
		return;
	}

	// -------------------------------------

	auto it = clients_.find(fd);

	if (it == clients_.end())
		return handleDisconnect_(fd, DisconnectStatus::PROBLEM_MAP_NOT_FOUND);

	CLIENTBUFFER &buffer = it->second;

	// -------------------------------------

	auto available = buffer.size();

	if (available <= 0){
		// this must never happen, disconnect.
		return handleDisconnect_(fd, DisconnectStatus::PROBLEM_BUFFER_WRITE);
	}

	ssize_t const size = ::write(fd, buffer.data(), available);

	// -------------------------------------

	if (size <= 0)
		return handleSocketOps_(fd, size);

	buffer.pop((size_t) size);

	buffer.restartTimer();

	if (buffer.size() == 0){
		// process with read
		selector_.updateFD(fd, selector::FDEvent::READ);

		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq -0x1c(%rbp), %rdx
movl %esi, (%rdx)
movq 0x20(%rdi), %rdi
movq 0x28(%r14), %rsi
callq 0x2c02
cmpq 0x28(%r14), %rax
jne 0x2a1f
movq 0x48(%r14), %rdx
leaq 0x40(%r14), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x29de
movq %rax, %rcx
xorl %esi, %esi
cmpl %ebx, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x29c7
movq %rax, %r15
cmpq %rax, %rcx
je 0x29f0
cmpl %ebx, 0x20(%rcx)
cmovgq %rax, %rcx
movq %rcx, %r15
cmpq %rax, %r15
je 0x2a10
movzwl 0x26(%r15), %edx
movzwl 0x24(%r15), %eax
cmpw %ax, %dx
jne 0x2a2a
movq %r14, %rdi
movl %ebx, %esi
movl $0x7, %edx
jmp 0x2a1a
movq %r14, %rdi
movl %ebx, %esi
movl $0x5, %edx
callq 0x2a9c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
subq %rax, %rdx
leaq (%r15,%rax), %rsi
addq $0x28, %rsi
movl %ebx, %edi
callq 0x20b0
testq %rax, %rax
jle 0x2a5f
movzwl 0x26(%r15), %edx
movzwl 0x24(%r15), %ecx
subq %rcx, %rdx
cmpq %rax, %rdx
jb 0x2a75
jne 0x2a6e
movl $0x0, 0x24(%r15)
jmp 0x2a75
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x2b40
jmp 0x2a1f
addl %eax, %ecx
movw %cx, 0x24(%r15)
callq 0x3620
movl %eax, 0x428(%r15)
movzwl 0x26(%r15), %eax
cmpw 0x24(%r15), %ax
jne 0x2a1f
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x34aa
jmp 0x2a1f
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::handleWorker_(int, net::ClientBuffer<1024ul>&)
bool AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::handleWorker_(int const fd, CLIENTBUFFER &buffer){
//	static const char *redis_ok  = "$2\r\nOK\r\n";
//	static const char *redis_err = "-ERR Error\r\n";

	const WorkerStatus status = worker_( buffer );

	switch( status ){
	case WorkerStatus::PASS:
		return false;

	case WorkerStatus::READ:
		selector_.updateFD(fd, selector::FDEvent::READ);

		return true;

	case WorkerStatus::WRITE:
		selector_.updateFD(fd, selector::FDEvent::WRITE);

		return true;

	case WorkerStatus::DISCONNECT:
		handleDisconnect_(fd, DisconnectStatus::WORKER_NORMAL);

		return true;

	case WorkerStatus::SHUTDOWN:
	//	handleDisconnect_(fd, DisconnectStatus::WORKER_NORMAL);
		keepProcessing_ = false;

		return true;

	default:
	case WorkerStatus::DISCONNECT_ERROR:
		handleDisconnect_(fd, DisconnectStatus::WORKER_ERROR);

		return true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
addq $0x18, %rdi
movq %rdx, %rsi
callq 0x2fe8
cmpl $0x5, %eax
ja 0x2bbf
movl %eax, %eax
leaq 0x1462(%rip), %rcx      # 0x4014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
jmp 0x2bfd
movq %r14, %rdi
movl %ebx, %esi
movl $0x4, %edx
jmp 0x2bef
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
jmp 0x2bde
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x34aa
jmp 0x2bfb
movq %r14, %rdi
movl %ebx, %esi
movl $0x3, %edx
callq 0x2a9c
jmp 0x2bfb
movb $0x0, 0x6c(%r14)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::insertFD_(int)
bool AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::insertFD_(int const fd){
	// one for server fd
	if (connectedClients_ + 1 >= selector_.maxFD() )
		return false;

	bool const result = selector_.insertFD(fd);

	if (result == false)
		return false;

	//clients_.insert(std::make_pair(fd, CLIENTBUFFER{}));
	clients_[fd];

	++connectedClients_;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, -0x14(%rbp)
movl 0x68(%rdi), %r14d
incl %r14d
callq 0x33b0
cmpl %eax, %r14d
jae 0x2cec
movl -0x14(%rbp), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x342e
movl %eax, %r14d
testb %al, %al
je 0x2cef
leaq 0x38(%rbx), %rdi
leaq -0x14(%rbp), %rsi
callq 0x2cfc
incl 0x68(%rbx)
jmp 0x2cef
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]asyncore_cpp/net/selector/pollselector.cc
// Function: net::selector::PollSelector::wait(int)
WaitStatus PollSelector::wait(int const timeout){
	int const activity = poll(statusData_.data(), statusData_.size(), timeout);

	if (activity < 0)
		return WaitStatus::ERROR;

	if (activity == 0)
		return WaitStatus::NONE;

	return WaitStatus::OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %edx
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
subq %rax, %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0x21f0
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl $0x2, %eax
cmovnsl %ecx, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]asyncore_cpp/net/sockets.cc
// Function: net::socket_create(net::SOCKET_TCP, char const*, unsigned short, unsigned short, int)
int socket_create(const SOCKET_TCP,  const char *ip, uint16_t const port, uint16_t const backlog, int const options) noexcept{
	int fd = socket(AF_INET , SOCK_STREAM , 0);

	if(fd < 0)
		return SOCKET_ERROR_CREATE;

	int const opt = 1;
	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, & opt, sizeof opt) < 0){
		::close(fd);
		return SOCKET_ERROR_OPTIONS;
	}

	if (options & SOCKET_NONBLOCK)
	if (! socket_makeNonBlocking(fd) ){
		::close(fd);
		return SOCKET_ERROR_NONBLOCK;
	}

	if (options & SOCKET_TCPNODELAY)
	if (! socket_makeTCPNoDelay(fd) ){
		::close(fd);
		return SOCKET_ERROR_NODELAY;
	}

	struct sockaddr_in address;

	address.sin_family = AF_INET;
	address.sin_addr.s_addr = INADDR_ANY;
	address.sin_port = htons(port);

	if (bind(fd, (struct sockaddr *) & address, sizeof address) < 0){
		::close(fd);
		return SOCKET_ERROR_BIND;
	}

	if (listen(fd, backlog ? backlog : SOMAXCONN) < 0){
		::close(fd);
		return SOCKET_ERROR_BACKLOG;
	}

	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %r12d
movl %edx, %r14d
movl %esi, %r15d
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2080
testl %eax, %eax
js 0x37ed
movl %eax, %ebx
leaq -0x24(%rbp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x2230
testl %eax, %eax
js 0x37f4
testb $0x1, %r12b
je 0x376b
movl %ebx, %edi
callq 0x3663
testb %al, %al
je 0x3802
testb $0x2, %r12b
je 0x379a
leaq -0x34(%rbp), %rcx
movl $0x1, (%rcx)
movl %ebx, %edi
movl $0x6, %esi
movl $0x1, %edx
movl $0x4, %r8d
callq 0x2230
testl %eax, %eax
js 0x381e
leaq -0x34(%rbp), %rsi
movw $0x2, (%rsi)
movl $0x0, 0x4(%rsi)
rolw $0x8, %r15w
movw %r15w, 0x2(%rsi)
movl %ebx, %edi
movl $0x10, %edx
callq 0x2060
testl %eax, %eax
js 0x3810
testw %r14w, %r14w
movl $0x1000, %eax           # imm = 0x1000
cmovnel %r14d, %eax
movzwl %ax, %esi
movl %ebx, %edi
callq 0x21b0
testl %eax, %eax
jns 0x382a
movl %ebx, %edi
callq 0x2240
movl $0xfffffffa, %ebx       # imm = 0xFFFFFFFA
jmp 0x382a
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x382a
movl %ebx, %edi
callq 0x2240
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x382a
movl %ebx, %edi
callq 0x2240
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
jmp 0x382a
movl %ebx, %edi
callq 0x2240
movl $0xfffffffb, %ebx       # imm = 0xFFFFFFFB
jmp 0x382a
movl %ebx, %edi
callq 0x2240
movl $0xfffffffc, %ebx       # imm = 0xFFFFFFFC
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x2766
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]asyncore_cpp/net/sockets.cc
// Function: net::socket_create(net::SOCKET_UNIX, char const*, unsigned short, int)
int socket_create(const SOCKET_UNIX, const char *path, uint16_t const backlog, int const options) noexcept{
	struct sockaddr_un address;

	if (sizeof address.sun_path < strlen(path))
		return SOCKET_NAME_SIZE;


	int fd = socket(AF_UNIX , SOCK_STREAM , 0);

	if(fd < 0)
		return SOCKET_ERROR_CREATE;

	if (options & SOCKET_NONBLOCK)
	if (! socket_makeNonBlocking(fd) ){
		::close(fd);
		return SOCKET_ERROR_NONBLOCK;
	}

	//struct sockaddr_in address
	address.sun_family = AF_UNIX;
	strcpy(address.sun_path, path);

	unlink(address.sun_path);

	if (bind(fd, (struct sockaddr *) & address, sizeof address) < 0){
		::close(fd);
		return SOCKET_ERROR_BIND;
	}

	if (listen(fd, backlog ? backlog : SOMAXCONN) < 0){
		::close(fd);
		return SOCKET_ERROR_BACKLOG;
	}

	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edx, %r12d
movl %esi, %r14d
movq %rdi, %r15
callq 0x20e0
movl $0xfffffff9, %ebx       # imm = 0xFFFFFFF9
cmpq $0x6c, %rax
ja 0x3918
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2080
testl %eax, %eax
js 0x38f7
movl %eax, %ebx
testb $0x1, %r12b
je 0x3895
movl %ebx, %edi
callq 0x3663
testb %al, %al
je 0x390c
leaq -0x8c(%rbp), %r12
movw $0x1, -0x2(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x2160
movq %r12, %rdi
callq 0x20f0
leaq -0x8e(%rbp), %rsi
movl %ebx, %edi
movl $0x6e, %edx
callq 0x2060
testl %eax, %eax
js 0x38fe
testw %r14w, %r14w
movl $0x1000, %eax           # imm = 0x1000
cmovnel %r14d, %eax
movzwl %ax, %esi
movl %ebx, %edi
callq 0x21b0
testl %eax, %eax
jns 0x3918
movl %ebx, %edi
callq 0x2240
movl $0xfffffffa, %ebx       # imm = 0xFFFFFFFA
jmp 0x3918
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x3918
movl %ebx, %edi
callq 0x2240
movl $0xfffffffb, %ebx       # imm = 0xFFFFFFFB
jmp 0x3918
movl %ebx, %edi
callq 0x2240
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x2766
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/test/demos/fstream/fstream.cc
// Function: ifstream_test(char const*)
void ifstream_test(const char *file)
{
  scdc::ifstream ifs;
  string line;

  ifs.open(file, ios_base::in);
  int i = 1;
  while (getline(ifs, line)) {
    cout << i << ": " << line << '\n';
    i++;
  }
  ifs.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rdi, %r14
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xc966
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0xca4c
movl $0x1, %ebp
leaq 0x8(%rsp), %r14
leaq 0x54319(%rip), %r12     # 0x60adb
leaq 0x7(%rsp), %r13
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb510
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbab0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xc845
movq 0x6d7d0(%rip), %rdi     # 0x79fd0
movl %ebp, %esi
callq 0xba20
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xb650
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0xb650
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0xb650
incl %ebp
jmp 0xc7c7
leaq 0x28(%rsp), %rdi
callq 0xca7a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xc86b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb550
leaq 0x6b1e6(%rip), %rax     # 0x77a58
leaq 0x150(%rsp), %rbx
movq %rax, -0x128(%rbx)
leaq 0x6b1f8(%rip), %rax     # 0x77a80
movq %rax, (%rbx)
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0xcc64
leaq 0x6b209(%rip), %rax     # 0x77aa8
movq %rax, -0x10(%r14)
leaq 0x6b226(%rip), %rax     # 0x77ad0
movq %rax, (%rbx)
movq $0x0, -0x8(%r14)
movq %rbx, %rdi
callq 0xb1a0
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc8d3
jmp 0xc8d3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xc8f2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb550
leaq 0x28(%rsp), %rdi
callq 0xcaa6
movq %rbx, %rdi
callq 0xba50
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/test/demos/fstream/fstream.cc
// Function: main
int main(int argc, char** argv)
{
  scdc_init(SCDC_INIT_DEFAULT);

  scdc_dataprov_t dpFS = scdc_dataprov_open("storeFS", "fs", "store/");

  const char *uri = "scdc:/storeFS/test.in";

  ifstream_test(uri);

  scdc_dataprov_close(dpFS);

  scdc_release();

  return 0;
}

// Assembly:
pushq %rbx
leaq 0x51d01(%rip), %rdi     # 0x5e60d
xorl %eax, %eax
callq 0xe8b9
leaq 0x506ea(%rip), %rdi     # 0x5d004
leaq 0x52b31(%rip), %rsi     # 0x5f452
leaq 0x506e4(%rip), %rdx     # 0x5d00c
xorl %eax, %eax
callq 0xec7b
movq %rax, %rbx
leaq 0x506da(%rip), %rdi     # 0x5d013
callq 0xc76c
movq %rbx, %rdi
callq 0xed76
callq 0xe9be
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/test/demos/fstream/../../../src/lib/redirect/fstream/basic_file_scdc.h
// Function: scdc::__basic_file_scdc<char>::xsputn(char const*, long)
streamsize 
      xsputn(const char* __s, streamsize __n)
      {
        TRACE(__class__, __func__, "n: %lld", (long long) __n);

        streamsize ret = -1;
        streamsize noffset = offset;

        if (!do_write) goto do_return;

#if BASIC_FILE_SCDC_APPEND
        if (do_append) noffset = 0;
#endif

        scdc_dataset_input_t input;

        scdc_dataset_input_unset(&input);
        SCDC_DATASET_INOUT_BUF_PTR(&input) = const_cast<char *>(__s);
        SCDC_DATASET_INOUT_BUF_SIZE(&input) = __n;
        SCDC_DATASET_INOUT_BUF_CURRENT(&input) = __n;
        input.total_size = __n;
        input.total_size_given = SCDC_DATASET_INOUT_TOTAL_SIZE_GIVEN_EXACT;

        char cmd[256];
        sprintf(cmd, "put %" scdcint_fmt "%c:%" scdcint_fmt,
#if BASIC_FILE_SCDC_APPEND
        (do_append)?0:
#endif
        noffset,
#if BASIC_FILE_SCDC_APPEND
        (do_append)?'B':
#endif
        'F', __n);

        if (scdc_dataset_cmd(_M_dataset, cmd, &input, NULL) != SCDC_SUCCESS) goto do_return;

        ret = __n;
        noffset += __n;

do_return:
        if (ret >= 0)
        {
#if BASIC_FILE_SCDC_APPEND
          if (!do_append)
#endif
          {
            offset = noffset;
          }
        }

        TRACE(__class__, __func__, "return: %lld, offset: %lld", (long long) ret, (long long) offset);

        return ret;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq $-0x1, %rax
cmpb $0x1, 0xa(%rdi)
jne 0xdd86
movq %rdx, %r15
movq %rsi, %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x20734
movq %r12, 0x10(%r13)
movq %r15, 0x18(%r13)
movq %r15, 0x20(%r13)
movq %r15, 0x28(%r13)
movb $0x78, 0x30(%r13)
leaq 0x4f2e7(%rip), %rsi     # 0x5d029
xorl %ebp, %ebp
leaq 0x60(%rsp), %r12
movq %r12, %rdi
movq %r14, %rdx
movl $0x46, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0xb0e0
movq (%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x102fc
cmpq $0x1, %rax
movq $-0x1, %rax
cmoveq %r15, %rax
cmoveq %r15, %rbp
addq %rbp, %r14
testq %rax, %rax
js 0xdd8f
movq %r14, 0x10(%rbx)
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/test/demos/fstream/../../../src/lib/redirect/fstream/basic_file_scdc.h
// Function: scdc::__basic_file_scdc<char>::seekoff(long, std::_Ios_Seekdir)
streamoff
      seekoff(streamoff __off, ios_base::seekdir __way) throw ()
      {
        TRACE(__class__, __func__, "");

        streamoff ret = -1;

        if (__way == ios_base::end)
        {
          char buf[32];
          scdc_dataset_output_t output;

          scdc_dataset_output_unset(&output);
          SCDC_DATASET_INOUT_BUF_PTR(&output) = buf;
          SCDC_DATASET_INOUT_BUF_SIZE(&output) = sizeof(buf) - 1;

          if (scdc_dataset_cmd(_M_dataset, "ls", NULL, &output) != SCDC_SUCCESS) goto do_return;

          long long o;
          std::string s(static_cast<const char *>(SCDC_DATASET_INOUT_BUF_PTR(&output)), SCDC_DATASET_INOUT_BUF_CURRENT(&output));
          sscanf(s.c_str(), "f:%lld|", &o);
          offset = o;
          __way = ios_base::cur;

          while (output.next) output.next(&output, 0);
        }

        switch (__way)
        {
          case ios_base::beg:
            offset = std::max(static_cast<streamoff>(0), __off);
            ret = offset;
            break;
          case ios_base::cur:
            offset += __off;
            ret = offset;
            break;
          default:
            ret = -1;
            break;
        }

        if (ret >= 0) eof = false;

do_return:
        return ret;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, %edx
jne 0xdf9b
leaq 0x28(%rsp), %rdi
callq 0x20754
leaq 0x80(%rsp), %rax
leaq 0x28(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq $0x1f, 0x18(%rcx)
movq (%rbx), %rdi
leaq 0x50049(%rip), %rsi     # 0x5df4d
xorl %edx, %edx
xorl %eax, %eax
callq 0x102fc
movq %rax, %r15
movl $0x2, %edx
cmpq $0x1, %rax
jne 0xdf8e
movq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x48(%rsp), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xdfea
movq (%rsp), %rdi
leaq 0x506e3(%rip), %rsi     # 0x5e627
leaq 0x20(%rsp), %r12
movq %r12, %rdx
xorl %eax, %eax
callq 0xb520
movq (%r12), %rax
movq %rax, 0x10(%rbx)
leaq 0x28(%rsp), %r12
movq 0x60(%rsp), %rax
testq %rax, %rax
je 0xdf73
movq %r12, %rdi
xorl %esi, %esi
callq *%rax
jmp 0xdf60
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xdf89
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb550
movl $0x1, %edx
movq $-0x1, %rax
cmpq $0x1, %r15
jne 0xdfce
cmpl $0x1, %edx
je 0xdfba
movq $-0x1, %rax
testl %edx, %edx
jne 0xdfc5
xorl %eax, %eax
testq %r14, %r14
cmovgq %r14, %rax
movq %rax, 0x10(%rbx)
jmp 0xdfc5
addq 0x10(%rbx), %r14
movq %r14, 0x10(%rbx)
movq %r14, %rax
testq %rax, %rax
js 0xdfce
movb $0x0, 0x18(%rbx)
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xdfe1
movq %rax, %rdi
callq 0xcb2a
nop
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/app/icnf/icnf.c
// Function: msg
static void msg (const char * fmt, ...) {
  va_list ap;
  fflush (stderr);
  printf ("c [icnf] ");
  va_start (ap, fmt);
  vprintf (fmt, ap);
  va_end (ap);
  fputc ('\n', stdout);
  fflush (stdout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x1f58
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 0x15099(%rip), %rax     # 0x16ff8
movq (%rax), %rdi
callq 0x1150
leaq 0xe344(%rip), %rdi      # 0x102b2
xorl %eax, %eax
callq 0x10b0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsi)
movq %r14, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1170
movq 0x1502c(%rip), %rbx     # 0x16fd0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x1100
movq (%rbx), %rdi
callq 0x1150
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/iTruth[P]klotski/./klotski_board.h
// Function: klotski_board::klotski_board<std::vector<int, std::allocator<int>>>(std::vector<int, std::allocator<int>> const&, int, int)
klotski_board::klotski_board(const T& situation_array, int dx, int dy):
	dx(dx), dy(dy),
	x_distribution(std::uniform_int_distribution<>(0, dx-1)),
	y_distribution(std::uniform_int_distribution<>(0, dy-1)){
		resize_board_to_fit();
		auto const_array_iterator = situation_array.cbegin();
		for(auto& i: situation){
			for(auto& n: i){
				if(const_array_iterator != situation_array.cend()){
					n = *const_array_iterator++;
				}else{
					throw std::invalid_argument("situation array is not fit");
				}
			}
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8a04(%rip), %rax      # 0xeca0
addq $0x10, %rax
movq %rax, (%rdi)
movl %edx, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
decl %edx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
xorl %eax, %eax
movl %eax, 0x30(%rdi)
movl %edx, 0x34(%rdi)
decl %ecx
movl %eax, 0x38(%rdi)
movl %ecx, 0x3c(%rdi)
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, 0x40(%rdi)
callq 0x68b2
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
cmpq %rcx, %rax
je 0x6317
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movq (%rax), %rdi
movq 0x8(%rax), %r8
cmpq %r8, %rdi
je 0x630e
cmpq %rsi, %rdx
je 0x631d
movl (%rdx), %r9d
addq $0x4, %rdx
movl %r9d, (%rdi)
addq $0x4, %rdi
jmp 0x62f4
addq $0x18, %rax
cmpq %rcx, %rax
jne 0x62ed
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x30f0
movq %rax, %r15
leaq 0x41a5(%rip), %rsi      # 0xa4d6
movq %rax, %rdi
callq 0x3400
movq 0x8c90(%rip), %rsi      # 0xefd0
movq 0x8c71(%rip), %rdx      # 0xefb8
movq %r15, %rdi
callq 0x33b0
jmp 0x6351
movq %rax, %r14
jmp 0x6361
movq %rax, %r14
movq %r15, %rdi
callq 0x31a0
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x5a36
movq %r14, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::resize_board_to_fit()
void klotski_board::resize_board_to_fit(){
	situation.resize(dy);
	situation.shrink_to_fit();
	std::for_each(situation.begin(), situation.end(),
			[this](std::vector<int>& vec){vec.resize(dx); vec.shrink_to_fit();});
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movslq 0xc(%rdi), %rsi
movq %r14, %rdi
callq 0x7b00
movq 0x28(%rbx), %rax
cmpq 0x20(%rbx), %rax
je 0x68dc
movq %r14, %rdi
callq 0x5d9e
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %r15
cmpq %r15, %r14
je 0x690d
movslq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x8462
movq 0x10(%r14), %rax
cmpq 0x8(%r14), %rax
je 0x6907
movq %r14, %rdi
callq 0x859c
addq $0x18, %r14
jmp 0x68e4
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::klotski_board(std::basic_fstream<char, std::char_traits<char>>&, int, int)
klotski_board::klotski_board(std::fstream& file, int dx, int dy):
	dx(dx), dy(dy),
	x_distribution(std::uniform_int_distribution<>(0, dx-1)),
	y_distribution(std::uniform_int_distribution<>(0, dy-1)){
		if(!file.is_open()){
			throw std::runtime_error("file is not open");
		}
		resize_board_to_fit();
		for(auto& i:situation){
			for(int& n: i){
				if(file.eof()){
					throw std::runtime_error("file is not fit");
				}
				file>>n;
				if(file.fail()){
					throw std::runtime_error("file is not a valid board file");
				}

			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8384(%rip), %rax      # 0xecb0
movq %rax, (%rdi)
movl %edx, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
decl %edx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
xorl %eax, %eax
movl %eax, 0x30(%rdi)
movl %edx, 0x34(%rdi)
decl %ecx
movl %eax, 0x38(%rdi)
movl %ecx, 0x3c(%rdi)
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, 0x40(%rdi)
leaq 0x80(%rsi), %rdi
callq 0x3060
testb %al, %al
je 0x6a2b
movq %rbx, %rdi
callq 0x68b2
movq 0x18(%rbx), %r12
movq 0x20(%rbx), %r13
cmpq %r13, %r12
je 0x69cc
movq (%r12), %r15
movq 0x8(%r12), %rbp
cmpq %rbp, %r15
je 0x69c6
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x69db
movq %r14, %rdi
movq %r15, %rsi
callq 0x3140
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
jne 0x69f9
addq $0x4, %r15
jmp 0x6992
addq $0x18, %r12
jmp 0x6984
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x30f0
movq %rax, %r15
leaq 0x3cb3(%rip), %rsi      # 0xa6a2
movq %rax, %rdi
callq 0x30b0
jmp 0x6a15
movl $0x10, %edi
callq 0x30f0
movq %rax, %r15
leaq 0x3989(%rip), %rsi      # 0xa396
movq %rax, %rdi
callq 0x30b0
movq 0x85d4(%rip), %rsi      # 0xeff0
movq 0x8575(%rip), %rdx      # 0xef98
movq %r15, %rdi
callq 0x33b0
movl $0x10, %edi
callq 0x30f0
movq %rax, %r15
leaq 0x3c52(%rip), %rsi      # 0xa691
movq %rax, %rdi
callq 0x30b0
movq 0x85a2(%rip), %rsi      # 0xeff0
movq 0x8543(%rip), %rdx      # 0xef98
movq %r15, %rdi
callq 0x33b0
jmp 0x6a63
jmp 0x6a72
jmp 0x6a63
movq %rax, %r14
movq %r15, %rdi
callq 0x31a0
jmp 0x6a75
jmp 0x6a72
movq %rax, %r14
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x5a36
movq %r14, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::reset()
void klotski_board::reset() noexcept{
	resize_board_to_fit();
	int inc = 1;
	for(auto& i: situation){
		for(int& n: i){
			n = inc++;
		}
	}
	situation[dy - 1][dx - 1] = 0;
	zero_x = dx - 1;
	zero_y = dy - 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x68b2
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
cmpq %rcx, %rax
je 0x6b07
movl $0x1, %edx
movq %rax, %rsi
movq (%rsi), %rdi
movq 0x8(%rsi), %r8
cmpq %r8, %rdi
je 0x6afe
movl %edx, (%rdi)
incl %edx
addq $0x4, %rdi
jmp 0x6aef
addq $0x18, %rsi
cmpq %rcx, %rsi
jne 0x6ae8
movslq 0xc(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
movslq 0x8(%rbx), %rdx
movq -0x18(%rax,%rcx,8), %rax
movl $0x0, -0x4(%rax,%rdx,4)
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %ecx
decl %eax
movl %eax, 0x10(%rbx)
decl %ecx
movl %ecx, 0x14(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x563d
// File: /workspace/github_cpp_makefile_star2_O1/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::upset(int)
void klotski_board::upset(int depth) noexcept{
	bool is_horizontal = orientation_distribution(random_engine);
	for (int i = 0; i < depth; ++i) {
		if(is_horizontal){
			while(!move_item(x_distribution(random_engine), zero_y));
		}else{
			while(!move_item(zero_x, y_distribution(random_engine)));
		}
		is_horizontal = !is_horizontal;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x885f(%rip), %rdi      # 0xf3b0
callq 0x7b75
movl %ebx, 0x4(%rsp)
testl %ebx, %ebx
jle 0x6bdb
movsd 0x40(%r14), %xmm1
ucomisd %xmm0, %xmm1
seta %bl
leaq 0x38(%r14), %r15
leaq 0x30(%r14), %r12
movl $0x0, (%rsp)
leaq 0x882f(%rip), %r13      # 0xf3b0
testb $0x1, %bl
je 0x6ba8
movq %r12, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x7de0
movl 0x14(%r14), %edx
movq (%r14), %rcx
movq %r14, %rdi
movl %eax, %esi
callq *(%rcx)
testb %al, %al
je 0x6b86
jmp 0x6bca
movl 0x10(%r14), %ebp
movq %r15, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x7de0
movq (%r14), %rcx
movq %r14, %rdi
movl %ebp, %esi
movl %eax, %edx
callq *(%rcx)
testb %al, %al
je 0x6ba8
xorb $0x1, %bl
movl (%rsp), %eax
incl %eax
movl %eax, (%rsp)
cmpl 0x4(%rsp), %eax
jne 0x6b81
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6bee
jmp 0x6bee
movq %rax, %rdi
callq 0x563d
// File: /workspace/github_cpp_makefile_star2_O1/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::print_line(int, int, std::ostream&)
void klotski_board::print_line(int dx, int space_n, std::ostream& os) noexcept{
	os<<std::setw(space_n)<<" ";
	for(int j=0; j<dx; ++j){
		os<<std::setw(space_n+1)<<std::setfill('-')<<"+";
	}
	os<<'+'<<std::endl<<std::setfill(' ');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movl %edi, %ebp
movq (%rdx), %rax
movq -0x18(%rax), %rax
movslq %esi, %rcx
movq %rcx, 0x10(%rdx,%rax)
leaq 0x33c5(%rip), %rsi      # 0xa3f9
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3290
testl %ebp, %ebp
jle 0x70a8
incl %r14d
movslq %r14d, %r12
leaq 0x3660(%rip), %r14      # 0xa6b2
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movq %r12, 0x10(%rbx,%rcx)
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r15
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0x708c
movq %r15, %rdi
movl $0x20, %esi
callq 0x3230
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x2d, 0xe0(%r15)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3290
decl %ebp
jne 0x7052
leaq 0xf(%rsp), %rsi
movb $0x2b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3290
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
movq %rax, %rbx
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
addq %rcx, %rbx
cmpb $0x0, 0xe1(%rax,%rcx)
jne 0x7118
movq %rbx, %rdi
movl $0x20, %esi
callq 0x3230
movb %al, 0xe0(%rbx)
movb $0x1, 0xe1(%rbx)
movb $0x20, 0xe0(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x712e
movq %rax, %rdi
callq 0x563d
// File: /workspace/github_cpp_makefile_star2_O1/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::move_item(int, int)
bool klotski_board::move_item(int x, int y){
	auto info = get_pos_info(x, y);
	if(info->is_item_can_move){
		if(info->zero_distance != 1){
			if(info->Orientation == pos_info::Horizontal){
				move_item(x, info->is_zero_in_top_or_left?y-1:y+1);
			}else{
				move_item(info->is_zero_in_top_or_left?x-1:x+1, y);
			}
		}
		std::swap(situation[y][x], get_zero());
		zero_x = x;
		zero_y = y;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x71f6
movq (%rbx), %rax
movb 0x5(%rax), %bl
cmpb $0x1, %bl
jne 0x71be
cmpl $0x1, 0x8(%rax)
je 0x7190
movl (%rax), %esi
movzbl 0x4(%rax), %eax
negl %eax
orl $0x1, %eax
xorl %edx, %edx
testl %esi, %esi
movq (%r14), %rcx
cmovnel %eax, %esi
cmovel %eax, %edx
addl %r15d, %esi
addl %ebp, %edx
movq %r14, %rdi
callq *(%rcx)
movslq %ebp, %rax
movq 0x18(%r14), %rcx
leaq (%rax,%rax,2), %rax
movq (%rcx,%rax,8), %r12
movq %r14, %rdi
callq 0x73b6
movslq %r15d, %rcx
movl (%r12,%rcx,4), %edx
movl (%rax), %esi
movl %esi, (%r12,%rcx,4)
movl %edx, (%rax)
movl %r15d, 0x10(%r14)
movl %ebp, 0x14(%r14)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x71cd
callq 0x5648
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x71ee
callq 0x5648
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O1/iTruth[P]klotski/klotski_board.cpp
// Function: klotski_board::get_zero()
int& klotski_board::get_zero(){
	if(situation[zero_y][zero_x] != 0){
		for(int i=0; i<dy; ++i){
			for(int j=0; j<dx; ++j){
				if(situation[i][j] == 0){
					zero_x = j;
					zero_y = i;
					return situation[i][j];
				}
			}
		}
	}else{
		return situation[zero_y][zero_x];
	}
	throw std::runtime_error("Can not find zero on klotski board");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movslq 0x14(%rdi), %rax
movq 0x18(%rdi), %rcx
leaq (%rax,%rax,2), %rdx
movslq 0x10(%rdi), %rax
movq (%rcx,%rdx,8), %rdx
cmpl $0x0, (%rdx,%rax,4)
je 0x7465
movslq 0xc(%rdi), %rsi
testq %rsi, %rsi
setg %dl
jle 0x746b
movslq 0x8(%rdi), %r8
testq %r8, %r8
setg %r9b
movl %r8d, %r10d
xorl %r11d, %r11d
testl %r8d, %r8d
jle 0x7433
leaq (%r11,%r11,2), %rbx
movq (%rcx,%rbx,8), %rbx
cmpl $0x0, (%rbx)
je 0x7438
movl $0x1, %r15d
cmpq %r15, %r10
je 0x744c
leaq 0x1(%r15), %r14
cmpl $0x0, (%rbx,%r15,4)
movq %r14, %r15
jne 0x7414
decq %r14
cmpq %r8, %r14
setl %bpl
jmp 0x743e
movl %r9d, %ebp
jmp 0x7453
xorl %r14d, %r14d
movl %r9d, %ebp
leaq (%rbx,%r14,4), %rax
movl %r14d, 0x10(%rdi)
movl %r11d, 0x14(%rdi)
jmp 0x7453
cmpq %r8, %r15
setl %bpl
testb %bpl, %bpl
jne 0x746b
incq %r11
cmpq %rsi, %r11
setb %dl
jne 0x73fc
jmp 0x746b
leaq (%rdx,%rax,4), %rax
jmp 0x7470
testb $0x1, %dl
je 0x747b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x30f0
movq %rax, %rbx
leaq 0x3227(%rip), %rsi      # 0xa6b6
movq %rax, %rdi
callq 0x30b0
movq 0x7b52(%rip), %rsi      # 0xeff0
movq 0x7af3(%rip), %rdx      # 0xef98
movq %rbx, %rdi
callq 0x33b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x33d0