LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/Moving.cpp
// Function: MyMoving::get_possible_moveset(Point const&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
vector<Point> MyMoving :: get_possible_moveset(const Point &p, const vector<vector<int>> &maze){
    vector<Point> possibleMoveSet;

    int y = p.getY();
    int x = p.getX();

    if(maze[y+1][x] == DIADROMOS || maze[y+1][x] == POTERAKOS ) {

        Point p1(x,y+1);
        possibleMoveSet.push_back(p1);
    }

    if(maze[y-1][x] == DIADROMOS || maze[y-1][x] == POTERAKOS) {
        Point p1(x,y-1);
        possibleMoveSet.push_back(p1);
    }

    if(maze[y][x+1] == DIADROMOS || maze[y][x+1] == POTERAKOS) {
        Point p1(x+1,y);
        possibleMoveSet.push_back(p1);
    }

    if(maze[y][x-1] == DIADROMOS || maze[y][x-1] == POTERAKOS) {
        Point p1(x-1,y);
        possibleMoveSet.push_back(p1);
    }


    return possibleMoveSet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x40(%rbp)
movq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x5766
movl %eax, %r14d
movq %r12, %rdi
callq 0x5752
movl %eax, %r12d
leal 0x1(%r14), %edx
movslq %edx, %rcx
movq (%rbx), %rax
leaq (%rcx,%rcx,2), %rcx
movslq %r12d, %r13
movq (%rax,%rcx,8), %rcx
movl (%rcx,%r13,4), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0x5c31
leaq -0x38(%rbp), %rdi
movl %r12d, %esi
callq 0x5866
leaq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x49c6
leaq -0x38(%rbp), %rdi
callq 0x587c
movq (%rbx), %rax
leal -0x1(%r14), %edx
movslq %edx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %rcx
movl (%rcx,%r13,4), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0x5c71
leaq -0x38(%rbp), %rdi
movl %r12d, %esi
callq 0x5866
leaq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x49c6
leaq -0x38(%rbp), %rdi
callq 0x587c
movq (%rbx), %rax
movslq %r14d, %rcx
leaq (%rcx,%rcx,2), %r15
movq (%rax,%r15,8), %rax
movl 0x4(%rax,%r13,4), %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0x5cb7
leal 0x1(%r12), %esi
leaq -0x38(%rbp), %rdi
movl %r14d, %edx
callq 0x5866
leaq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x49c6
leaq -0x38(%rbp), %rdi
callq 0x587c
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
movl -0x4(%rax,%r13,4), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x5cec
decl %r12d
leaq -0x38(%rbp), %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0x5866
leaq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x49c6
leaq -0x38(%rbp), %rdi
callq 0x587c
movq -0x40(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5d0b
jmp 0x5d1d
jmp 0x5d0b
jmp 0x5d1d
jmp 0x5d0b
jmp 0x5d1d
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x587c
jmp 0x5d20
jmp 0x5d1d
jmp 0x5d1d
movq %rax, %r14
movq -0x40(%rbp), %rdi
callq 0x4ab0
movq %r14, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/Moving.cpp
// Function: MyMoving::getShortestEuclidean(Poter&, std::vector<Point, std::allocator<Point>> const&)
Point MyMoving::getShortestEuclidean(Poter &poter, const vector<Point> &possibleMoveSet) {
    int flag_first = 0;
    Point p(0,0);
    float min_euclidean = 0.0;
    for(Point points:possibleMoveSet){
        if(flag_first == 0){
            flag_first = 1;
            p.setY(points.getY());
            p.setX(points.getX());
            min_euclidean = points.euclidean(poter.getPoint());
        }
        else{
            float temp = points.euclidean(poter.getPoint());
            if(temp<min_euclidean){
                p.setY(points.getY());
                p.setX(points.getX());
            }
        }
    }

    return p;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x5866
movq (%r15), %r13
movq 0x8(%r15), %rax
movq %rax, -0x40(%rbp)
cmpq %rax, %r13
je 0x5e4c
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movb $0x1, %al
leaq 0x3ee5(%rip), %r14      # 0x9c60
addq $0x10, %r14
leaq -0x50(%rbp), %r15
leaq -0x60(%rbp), %r12
movq %r14, -0x50(%rbp)
movq 0x8(%r13), %rcx
movq %rcx, -0x48(%rbp)
testb $0x1, %al
je 0x5de1
movq %r15, %rdi
callq 0x5766
movq %rbx, %rdi
movl %eax, %esi
callq 0x575c
movq %r15, %rdi
callq 0x5752
movq %rbx, %rdi
movl %eax, %esi
callq 0x5748
movq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0x582a
movq %r15, %rdi
movq %r12, %rsi
callq 0x5710
movss %xmm0, -0x2c(%rbp)
movq %r12, %rdi
callq 0x587c
jmp 0x5e34
movq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0x582a
movq %r15, %rdi
movq %r12, %rsi
callq 0x5710
movss %xmm0, -0x30(%rbp)
movq %r12, %rdi
callq 0x587c
movss -0x2c(%rbp), %xmm0
ucomiss -0x30(%rbp), %xmm0
jbe 0x5e34
movq %r15, %rdi
callq 0x5766
movq %rbx, %rdi
movl %eax, %esi
callq 0x575c
movq %r15, %rdi
callq 0x5752
movq %rbx, %rdi
movl %eax, %esi
callq 0x5748
movq %r15, %rdi
callq 0x587c
addq $0x10, %r13
xorl %eax, %eax
cmpq -0x40(%rbp), %r13
jne 0x5d87
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5e74
jmp 0x5e74
jmp 0x5e64
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x587c
jmp 0x5e77
jmp 0x5e74
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x587c
movq %rbx, %rdi
callq 0x587c
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/Moving.cpp
// Function: MyMoving::Move(Goblin&, Poter&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
Point MyMoving::Move(Goblin &goblin, Poter &poter, const vector<vector<int>> &maze) {
    vector<Point> possibleMoveSet;


    Point p = goblin.getPoint();
    mvaddch(p.getY(),p.getX(),' ');

    possibleMoveSet = get_possible_moveset(p,maze);

    possibleMoveSet.push_back(p);

    p = getShortestEuclidean(poter,possibleMoveSet);

    mvaddch(p.getY(),p.getX(),'G');


    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
callq 0x582a
movq 0x410b(%rip), %rax      # 0x9fd0
movq (%rax), %r12
movq %rbx, %rdi
callq 0x5766
movl %eax, %r13d
movq %rbx, %rdi
callq 0x5752
movq %r12, %rdi
movl %r13d, %esi
movl %eax, %edx
callq 0x3240
cmpl $-0x1, %eax
je 0x5f01
movq 0x40dc(%rip), %rax      # 0x9fd0
movq (%rax), %rdi
movl $0x20, %esi
callq 0x3090
leaq -0x70(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x5bac
leaq -0x40(%rbp), %r15
movaps (%r15), %xmm0
movq 0x10(%r15), %rax
leaq -0x70(%rbp), %r12
movaps (%r12), %xmm1
movaps %xmm1, (%r15)
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%r15)
leaq -0x58(%rbp), %rdi
movups %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
callq 0x4ab0
movq %r12, %rdi
callq 0x4ab0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49c6
leaq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movq %r14, %rsi
callq 0x5d32
leaq -0x58(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rbx)
callq 0x587c
movq 0x4042(%rip), %rax      # 0x9fd0
movq (%rax), %r14
movq %rbx, %rdi
callq 0x5766
movl %eax, %r15d
movq %rbx, %rdi
callq 0x5752
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x3240
cmpl $-0x1, %eax
je 0x5fca
movq 0x4013(%rip), %rax      # 0x9fd0
movq (%rax), %rdi
movl $0x47, %esi
callq 0x3090
leaq -0x40(%rbp), %rdi
callq 0x4ab0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5fee
jmp 0x5fee
movq %rax, %r14
jmp 0x5ff9
movq %rax, %r14
movq %rbx, %rdi
callq 0x587c
leaq -0x40(%rbp), %rdi
callq 0x4ab0
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/Gem.cpp
// Function: Gem::setPoint(std::vector<Point, std::allocator<Point>>&)
void Gem::setPoint(vector<Point> &startingPoints) {
    srand(time(nullptr));

    int size = (int) startingPoints.size();
    int rand_int = rand()%size;

    this->inMap.setX(startingPoints[rand_int].getX());
    this->inMap.setY(startingPoints[rand_int].getY());


    startingPoints.erase(startingPoints.begin()+0);


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0x31f0
movl %eax, %edi
callq 0x3200
movq 0x8(%rbx), %r15
subq (%rbx), %r15
shrq $0x4, %r15
callq 0x3070
cltd
idivl %r15d
movslq %edx, %r15
shlq $0x4, %r15
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x5752
movq %r14, %rdi
movl %eax, %esi
callq 0x5748
addq (%rbx), %r15
movq %r15, %rdi
callq 0x5766
movq %r14, %rdi
movl %eax, %esi
callq 0x575c
movq (%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x59cc
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/HighScore.cpp
// Function: HighScore::save(std::basic_ofstream<char, std::char_traits<char>>&)
void HighScore::save(ofstream &of) {
    for(int i=0;i<5;i++){
        if(score[i]!=-1){
            name[i].save(of);
            string str = to_string(score[i]);
            char *writeable = new char[str.size() + 1];
            copy(str.begin(),str.end(),writeable);
            writeable[str.size()] = '\0';
            of.write(writeable,sizeof(int));

        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq %rsi, -0x50(%rbp)
cmpl $-0x1, 0x34(%r14,%r15,4)
je 0x643b
leaq (%r15,%r15,4), %rax
leaq (%r14,%rax,2), %rsi
movl $0xa, %edx
movq %rbx, %rdi
callq 0x32e0
movl 0x34(%r14,%r15,4), %ebx
movl %ebx, %r12d
negl %r12d
cmovsl %ebx, %r12d
movl $0x1, %r13d
cmpl $0xa, %r12d
jb 0x63b3
movl $0x4, %r13d
movl %r12d, %eax
movl $0xd1b71759, %edx       # imm = 0xD1B71759
cmpl $0x63, %eax
jbe 0x63aa
cmpl $0x3e7, %eax            # imm = 0x3E7
jbe 0x63b0
cmpl $0x2710, %eax           # imm = 0x2710
jb 0x63b3
movl %eax, %ecx
imulq %rdx, %rcx
shrq $0x2d, %rcx
addl $0x4, %r13d
cmpl $0x1869f, %eax          # imm = 0x1869F
movl %ecx, %eax
ja 0x637a
addl $-0x3, %r13d
jmp 0x63b3
addl $-0x2, %r13d
jmp 0x63b3
decl %r13d
shrl $0x1f, %ebx
movl %ebx, %esi
addl %r13d, %esi
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
movl $0x2d, %edx
callq 0x3290
movq -0x48(%rbp), %rdi
addq %rbx, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x6b69
movq -0x40(%rbp), %r12
leaq 0x1(%r12), %rdi
callq 0x3030
movq -0x50(%rbp), %rbx
movq %rax, %r13
testq %r12, %r12
je 0x640c
movq -0x48(%rbp), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x3370
movb $0x0, (%r13,%r12)
movl $0x4, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x32e0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x643b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3230
incq %r15
cmpq $0x5, %r15
jne 0x6330
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x6473
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/HighScore.cpp
// Function: HighScore::load(std::basic_ifstream<char, std::char_traits<char>>&)
void HighScore::load(ifstream &inf) {
    int i=0;
    while (inf.eof()){
        name[i].load(inf);
        char *val = nullptr;
        inf.read(val,sizeof(int));
        this->score[i] = atoi(val);
        i++;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rsi), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rsi,%rax)
je 0x64dd
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x34(%rdi), %r15
movl $0xa, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32d0
movl $0x4, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x32d0
xorl %edi, %edi
callq 0x3350
movl %eax, (%r15)
movq (%rbx), %rax
movq -0x18(%rax), %rax
addq $0x4, %r15
addq $0xa, %r14
testb $0x2, 0x20(%rbx,%rax)
jne 0x649e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/HighScore.cpp
// Function: HighScore::operator<<(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
HighScore &HighScore::operator<<(string myname) {
    for(int i=0;i<4;i++){
        name[i+1] = name[i];
    }

    name[0].setname(std::move(myname));
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movzwl 0x8(%rbx,%rax), %ecx
movw %cx, 0x12(%rbx,%rax)
movq (%rbx,%rax), %rcx
movq %rcx, 0xa(%rbx,%rax)
addq $0xa, %rax
cmpq $0x28, %rax
jne 0x64f6
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rdi
leaq 0x10(%rsi), %rcx
cmpq %rcx, %rdi
je 0x6534
movq %rdi, -0x28(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x18(%rbp)
jmp 0x653d
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq %rax, %rdi
movq 0x8(%rsi), %rdx
movq %rdx, -0x20(%rbp)
movq %rcx, (%rsi)
xorl %ecx, %ecx
movq %rcx, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
movslq %edx, %rdx
testq %rdx, %rdx
cmovleq %rcx, %rdx
cmpq %rcx, %rdx
je 0x6572
movb (%rdi,%rcx), %sil
movb %sil, (%rbx,%rcx)
incq %rcx
cmpq $0xa, %rcx
jne 0x655c
cmpq %rax, %rdi
je 0x6583
movq -0x18(%rbp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Teris45[P]Maze-Game/HighScore.cpp
// Function: HighScore::operator<<(int)
HighScore &HighScore::operator<<(int myscore) {
    for(int i=0;i<4;i++){
        score[i+1] = score[i];
    }
    score[0] = myscore;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl 0x34(%rdi), %ecx
movl $0xe, %edx
movl %ecx, (%rax,%rdx,4)
incq %rdx
cmpq $0x12, %rdx
jne 0x659d
movl %esi, 0x34(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/tests/test_mymodel.cpp
// Function: test_mymodel()
void test_mymodel() {
	float* input = (float*)malloc(sizeof(float) * 1 * 3 * 224 * 224);
	LoadFromFile("../models/my_testmodel/input.dat", (char*)input);

	Model model;
	float* output;
	output = model.Run(input);

	int out_shape[4];
	unsigned long size;
	model.GetOutputShape(out_shape);
	// size = out_shape[0] * out_shape[1] * out_shape[2] * out_shape[3];
	size = out_shape[0] * out_shape[1];
	SaveToFile("../outputs/my_testmodel/output.dat", (char*)output, size * sizeof(float));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl $0x93000, %edi          # imm = 0x93000
callq 0x2240
movq %rax, %rbx
leaq 0x3a09(%rip), %rdi      # 0x6004
movq %rax, %rsi
xorl %edx, %edx
callq 0x45ca
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x267a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2960
movq -0x30(%rbp), %rcx
movq 0xc(%rcx), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
imull %ecx, %edx
movslq %edx, %rdx
shlq $0x2, %rdx
leaq 0x39e9(%rip), %rdi      # 0x6025
movq %rax, %rsi
callq 0x4c5d
leaq -0x50(%rbp), %rdi
callq 0x2b60
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2658
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2b60
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/tests/test_mymodel.cpp
// Function: Model::~Model()
~Model() {
		delete conv1, conv2, conv3;
		delete fc1, fc2;
		delete elt;
		delete cat;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x2b7a
movq %r14, %rdi
callq 0x2bd6
movl $0x80, %esi
movq %r14, %rdi
callq 0x21b0
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x2b98
movq %r14, %rdi
callq 0x2c04
movl $0x30, %esi
movq %r14, %rdi
callq 0x21b0
movq 0x30(%rbx), %rdi
movl $0x48, %esi
callq 0x21b0
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
je 0x2bc4
movq %rbx, %rdi
callq 0x2c32
movl $0x60, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/./include/Convolution.h
// Function: Convolution::~Convolution()
~Convolution() { 
		if (weight_data != nullptr) 
			free(weight_data); 
		if (bias_data != nullptr)
			free(bias_data);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x2bed
callq 0x2200
movq 0x70(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x2c01
popq %rbx
popq %rbp
jmp 0x2200
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/./include/FullyConnection.h
// Function: FullyConnection::~FullyConnection()
~FullyConnection(){
		if (weight_data != nullptr)
			free(weight_data);
		if (bias_data != nullptr)
			free(bias_data);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x2c1b
callq 0x2200
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x2c2f
popq %rbx
popq %rbp
jmp 0x2200
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/./include/Concat.h
// Function: Concat::~Concat()
~Concat(){
		// Free in_shape
		while (!in_shape.empty()) {
			free(in_shape.back());
			in_shape.pop_back();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq %rax, (%rdi)
je 0x2c61
movq -0x8(%rax), %rdi
callq 0x2200
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
addq $-0x8, %rax
movq %rax, 0x8(%rbx)
cmpq %rax, %rcx
jne 0x2c44
leaq 0x28(%rbx), %rdi
callq 0x2c94
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2c84
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21b0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x2ccb
nop
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/src/FullyConnection.cpp
// Function: FullyConnection::FullyConnection(int, int*, bool, bool, bool)
FullyConnection::FullyConnection(int out_num, int ishape[], bool with_relu, bool wiht_bias, bool flatten) 
		: out_num(out_num), with_relu(with_relu), with_bias(with_bias){
	if (flatten) {
		in_shape[0] = ishape[0];
		in_shape[1] = ishape[1] * ishape[2] * ishape[3];
	} else {
		in_shape[0] = ishape[0];
		in_shape[1] = ishape[1];
	}

	out_shape[0] = ishape[0];
	out_shape[1] = out_num;

	weight_data = (float*)malloc(sizeof(float) * in_shape[1] * out_shape[1]);
	if (wiht_bias)
		bias_data = (float*)malloc(sizeof(float) * out_num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %r14d
movq %rdi, %rbx
movl %esi, (%rdi)
movb %cl, 0x14(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq $0x0, 0x28(%rdi)
movl (%rdx), %eax
movl %eax, 0x4(%rdi)
movl 0x4(%rdx), %eax
testl %r9d, %r9d
je 0x3ea9
imull 0x8(%rdx), %eax
imull 0xc(%rdx), %eax
movl %eax, 0x8(%rbx)
movl (%rdx), %ecx
movl %ecx, 0xc(%rbx)
movl %esi, 0x10(%rbx)
movslq %eax, %rdi
movslq %esi, %r15
shlq $0x2, %r15
imulq %r15, %rdi
callq 0x2240
movq %rax, 0x18(%rbx)
testb %r14b, %r14b
je 0x3edc
movq %r15, %rdi
callq 0x2240
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/src/FullyConnection.cpp
// Function: FullyConnection::Run(float*, bool)
float* FullyConnection::Run(float* in_data, bool keep_in) {
	float dat, wt, result;

	out_data = (float*)malloc(sizeof(float) * out_shape[0] * out_shape[1]);

	for (int idx_bs = 0; idx_bs < out_shape[0]; idx_bs++) {
		for (int idx_out = 0; idx_out < out_shape[1]; idx_out++) {
			result = 0.;
			for (int idx_in = 0; idx_in < in_shape[1]; idx_in++) {
				dat = in_data[idx_bs * in_shape[0] + idx_in];
				wt = weight_data[idx_out * in_shape[1] + idx_in];
				result += dat * wt;
			}
			if (with_bias)
				result += bias_data[idx_out];
			if (with_relu && result < 0)
				result = 0;
			out_data[idx_bs * out_shape[1] + idx_out] = result;
		}
	}

	if (!keep_in)
		free(in_data);

	return out_data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, -0x34(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdi, %rbx
movslq 0xc(%rdi), %r14
movslq 0x10(%rdi), %r13
movq %r14, %rdi
imulq %r13, %rdi
shlq $0x2, %rdi
callq 0x2240
movq %rbx, -0x48(%rbp)
movq %rax, -0x30(%rbp)
movq %rax, 0x28(%rbx)
testq %r14, %r14
jle 0x3fd8
movq %r14, %rax
movq -0x48(%rbp), %rsi
movl 0x8(%rsi), %ecx
movslq 0x4(%rsi), %rdx
movq 0x18(%rsi), %rdi
movq %rdi, -0x50(%rbp)
movb 0x15(%rsi), %dil
movq 0x20(%rsi), %r8
movb 0x14(%rsi), %r9b
movslq %ecx, %r10
shlq $0x2, %r10
shlq $0x2, %rdx
xorl %r11d, %r11d
movq -0x40(%rbp), %r14
testl %r13d, %r13d
jle 0x3fcd
movq %r11, %rsi
imulq %r13, %rsi
movq -0x30(%rbp), %rbx
leaq (%rbx,%rsi,4), %r15
movq -0x50(%rbp), %rsi
xorl %ebx, %ebx
xorps %xmm0, %xmm0
testl %ecx, %ecx
jle 0x3fa0
xorl %r12d, %r12d
movss (%r14,%r12,4), %xmm1
mulss (%rsi,%r12,4), %xmm1
addss %xmm1, %xmm0
incq %r12
cmpq %r12, %rcx
jne 0x3f88
testb $0x1, %dil
je 0x3fac
addss (%r8,%rbx,4), %xmm0
testb $0x1, %r9b
je 0x3fbc
xorps %xmm1, %xmm1
maxss %xmm0, %xmm1
movaps %xmm1, %xmm0
movss %xmm0, (%r15,%rbx,4)
incq %rbx
addq %r10, %rsi
cmpq %r13, %rbx
jne 0x3f7e
incq %r11
addq %rdx, %r14
cmpq %rax, %r11
jne 0x3f64
cmpb $0x0, -0x34(%rbp)
jne 0x3ff3
movq -0x40(%rbp), %rdi
callq 0x2200
movq -0x48(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/src/helper.cpp
// Function: DecodeHuffman(Bit&, TarFile*)
Tree* DecodeHuffman(Bit& accessor, TarFile* tarfile) {
	Tree* left, * right;
	unsigned char value = 0;

	switch (accessor.Next()) {
	case -1:
		return nullptr;
	case 0:
		left = DecodeHuffman(accessor, tarfile);
		right = DecodeHuffman(accessor, tarfile);
		return new Tree(-1, left, right);
	case 1:
		value = 0;
		for (int i = 0; i < 8; i++) {
			value <<= 1;
			value += accessor.Next();
		}
		return new Tree(value, nullptr, nullptr);
	default:
		cerr << "DecodeHuffman: unknown bit" << endl;
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4d56
cmpl $-0x1, %eax
je 0x4539
testl %eax, %eax
je 0x4503
cmpl $0x1, %eax
jne 0x4544
movl $0x8, %r15d
xorl %r14d, %r14d
movl %r14d, %r12d
addb %r14b, %r12b
movq %rbx, %rdi
callq 0x4d56
movl %eax, %r14d
addb %r12b, %r14b
decl %r15d
jne 0x44d1
movl $0x18, %edi
callq 0x21a0
movzbl %r14b, %ecx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl %ecx, 0x10(%rax)
jmp 0x453b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x44a4
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x44a4
movq %rax, %rbx
movl $0x18, %edi
callq 0x21a0
movq %r15, (%rax)
movq %rbx, 0x8(%rax)
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
jmp 0x453b
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x4aa5(%rip), %rdi      # 0x8ff0
leaq 0x1e0f(%rip), %rsi      # 0x6361
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/src/helper.cpp
// Function: LoadFromFile(char const*, char*, TarFile*)
unsigned long LoadFromFile(const char* path, char* dst, TarFile* tarfile) {
	unsigned long byte_cnt = 0;
	if (nullptr != tarfile) {
		tarfile->GetFileContents(path, dst);
		byte_cnt = tarfile->GetFileSize(path);
	} else {
		char temp;
		ifstream in_file(path, ios::in | ios::binary);

		if (!in_file) {
			cerr << "Open file failed: " << path << endl;
			return 0;
		}
		while (in_file.read((char*)& temp, sizeof(temp))) {
			dst[byte_cnt] = temp;
			byte_cnt++;
		}
	}

	return byte_cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x4612
movq %rdx, %r15
movq %rdx, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x53be
movq %r15, %rdi
movq %r14, %rsi
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x54cc
leaq -0x230(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0xc, %edx
callq 0x2300
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x210(%rbp,%rax)
je 0x4676
movq 0x49af(%rip), %rbx      # 0x8ff0
leaq 0x1d34(%rip), %rsi      # 0x637c
movl $0x12, %edx
movq %rbx, %rdi
callq 0x21e0
testq %r14, %r14
je 0x46a7
movq %r14, %rdi
callq 0x20c0
movq 0x4987(%rip), %rdi      # 0x8ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0x21e0
jmp 0x46be
xorl %r14d, %r14d
leaq -0x21(%rbp), %r12
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x46ec
movb -0x21(%rbp), %al
movb %al, (%rbx,%r14)
incq %r14
jmp 0x467d
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x22d0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq 0x4914(%rip), %rdi      # 0x8ff0
callq 0x2050
movq %rax, %rdi
callq 0x2100
xorl %r14d, %r14d
leaq -0x230(%rbp), %rdi
callq 0x2070
movq %r14, %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x470d
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/src/helper.cpp
// Function: GetFileLength(char const*)
unsigned long GetFileLength(const char* path) {
	FILE* fp;
	fp =fopen(path, "r");
	if (nullptr == fp) {
		cerr << "GetFileLength: open file fail" << endl;
		exit(1);
	}
	fseek(fp, 0L, SEEK_END);
	long size = ftell(fp);
	fclose(fp);
	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x1d43(%rip), %rsi      # 0x6475
callq 0x21f0
testq %rax, %rax
je 0x4769
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21d0
movq %rbx, %rdi
callq 0x2030
movq %rax, %r14
movq %rbx, %rdi
callq 0x2190
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x4880(%rip), %rdi      # 0x8ff0
leaq 0x1c18(%rip), %rsi      # 0x638f
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/src/helper.cpp
// Function: SaveToFile(char const*, char*, unsigned long)
unsigned long SaveToFile(const char* path, char* src, unsigned long bytes) {
	ofstream out_file(path, ios::out | ios::binary);
	if (!out_file) {
		cerr << "Open result file failed." << endl;
		return 0;
	}
	out_file.write(src, bytes);
	return bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq -0x218(%rbp), %r15
movq %r15, %rdi
movl $0x14, %edx
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
je 0x4ce5
movq 0x434e(%rip), %rbx      # 0x8ff0
leaq 0x174d(%rip), %rsi      # 0x63f6
movl $0x18, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq 0x431c(%rip), %rdi      # 0x8ff0
callq 0x2050
movq %rax, %rdi
callq 0x2100
xorl %ebx, %ebx
jmp 0x4cf7
leaq -0x218(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2230
movq 0x42ca(%rip), %rax      # 0x8fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x210(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x218(%rbp,%rcx)
callq 0x2140
leaq -0x120(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2280
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/./include/helper.h
// Function: Bit::Next()
int Next() {
		if ( (ptr >= buffer + size) || (ptr == buffer + size - 1) && (idx + num_pad >= 8) )
			return -1;

		int ret = (*ptr & (1 << (7 - idx++))) ? 1 : 0;
		if (idx >= 8) {
			idx = 0;
			ptr++;
		}

		return ret;
	}

// Assembly:
movq 0x8(%rdi), %rcx
movslq 0x10(%rdi), %rsi
addq (%rdi), %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rsi, %rcx
jae 0x4db2
decq %rsi
movl 0x14(%rdi), %edx
cmpq %rsi, %rcx
jne 0x4d80
movl 0x18(%rdi), %esi
addl %edx, %esi
cmpl $0x7, %esi
jg 0x4db2
pushq %rbp
movq %rsp, %rbp
movzbl (%rcx), %esi
leal 0x1(%rdx), %eax
movl %eax, 0x14(%rdi)
movb $0x7, %al
subb %dl, %al
movzbl %al, %r8d
xorl %eax, %eax
btl %r8d, %esi
setb %al
cmpl $0x7, %edx
jl 0x4db1
movl $0x0, 0x14(%rdi)
incq %rcx
movq %rcx, 0x8(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/./include/helper.h
// Function: Bit::Bit(char const*, TarFile*)
Bit(const char* path, TarFile* tarfile = nullptr) {
		size = (nullptr != tarfile) ? tarfile->GetFileSize(path) : GetFileLength(path);
		buffer = new unsigned char[size];
		if (nullptr != tarfile)
			tarfile->GetFileContents(path, (char*)buffer);
		else
			LoadFromFile(path, (char*)buffer);
		num_pad = buffer[0];
		ptr = buffer + 1;
		idx = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, (%rdi)
testq %rdx, %rdx
je 0x4de0
movq %r15, %rdi
movq %r14, %rsi
callq 0x54cc
jmp 0x4de8
movq %r14, %rdi
callq 0x4724
movl %eax, 0x10(%rbx)
movslq %eax, %rdi
callq 0x2040
movq %rax, (%rbx)
testq %r15, %r15
je 0x4e0b
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x53be
jmp 0x4e18
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x45ca
movq (%rbx), %rax
movzbl (%rax), %ecx
movl %ecx, 0x18(%rbx)
incq %rax
movq %rax, 0x8(%rbx)
movl $0x0, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/src/TarFile.cpp
// Function: TarFile::TarFile(char const*)
TarFile::TarFile(const char* tar_name)
	: file(nullptr), size(0)
{
	file_names.clear();
	file_sizes.clear();
	file_data_start_addrs.clear();
	// fopen_s(&file, tar_name, "rb");
	file = fopen(tar_name, "rb");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x50(%rbx)
xorl %esi, %esi
callq 0x5732
movq 0x28(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x50a0
movq %rax, 0x30(%rbx)
movq 0x40(%rbx), %rax
cmpq %rax, 0x48(%rbx)
je 0x50ae
movq %rax, 0x48(%rbx)
leaq 0x1384(%rip), %rsi      # 0x6439
movq %r14, %rdi
callq 0x21f0
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/src/TarFile.cpp
// Function: TarFile::~TarFile()
TarFile::~TarFile()
{
	if (file) {
		fclose(file);
		file = nullptr;
	}
	file_names.clear();
	file_sizes.clear();
	file_data_start_addrs.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x50e4
callq 0x2190
movq $0x0, (%rbx)
leaq 0x10(%rbx), %r14
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x5732
movq 0x28(%rbx), %rdi
cmpq %rdi, 0x30(%rbx)
je 0x5102
movq %rdi, 0x30(%rbx)
movq 0x40(%rbx), %rax
cmpq %rax, 0x48(%rbx)
je 0x5110
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x5128
movq 0x50(%rbx), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x21b0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x5139
movq 0x38(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x55b2
nop
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/src/TarFile.cpp
// Function: TarFile::GetFileContents(char const*, char*)
bool TarFile::GetFileContents(const char* file_name, char* contents)
{
	bool flag = false;
	for (int i = 0; i < file_names.size(); i++) {
		std::string name_(file_name);

		if (file_names[i].compare(name_) == 0) {
			int file_size = file_sizes[i];
			flag = true;
			fseek(file, file_data_start_addrs[i], SEEK_SET);
			fread(contents, file_size, 1, file);
			fseek(file, 0, SEEK_SET);

			break;
		}
	}

	return flag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x5492
movq %rdi, %r15
xorl %r14d, %r14d
xorl %r12d, %r12d
xorl %ebx, %ebx
leaq -0x60(%rbp), %r13
movq %r13, %rdi
movq -0x40(%rbp), %rsi
leaq -0x29(%rbp), %rdx
callq 0x5620
movq 0x10(%r15), %rdi
addq %r14, %rdi
movq %r13, %rsi
callq 0x2060
movl %eax, %r13d
testl %eax, %eax
jne 0x5456
movq (%r15), %rdi
movq 0x28(%r15), %rax
movslq (%rax,%r12,8), %rbx
movq 0x40(%r15), %rax
movq (%rax,%r12,8), %rsi
xorl %edx, %edx
callq 0x21d0
movq (%r15), %rcx
movl $0x1, %edx
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x2290
movq (%r15), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21d0
movb $0x1, %bl
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x546f
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21b0
testl %r13d, %r13d
je 0x5494
movq 0x18(%r15), %rax
subq 0x10(%r15), %rax
incq %r12
sarq $0x5, %rax
addq $0x20, %r14
cmpq %r12, %rax
ja 0x53f0
jmp 0x5494
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x54c4
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/hey-yahei[P]ConvNet/src/TarFile.cpp
// Function: TarFile::GetFileSize(char const*)
size_t TarFile::GetFileSize(const char* file_name)
{
	size_t file_size{ 0 };

	for (int i = 0; i < file_names.size(); i++) {
		std::string name_(file_name);

		if (file_names[i].compare(name_) == 0) {
			file_size = file_sizes[i];
			break;
		}
	}

	return file_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x40(%rbp)
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x5569
movq %rdi, %r14
xorl %r15d, %r15d
leaq -0x60(%rbp), %r12
xorl %ebx, %ebx
movq $0x0, -0x38(%rbp)
movq %r12, %rdi
movq -0x40(%rbp), %rsi
leaq -0x29(%rbp), %rdx
callq 0x5620
movq 0x10(%r14), %rdi
addq %r15, %rdi
movq %r12, %rsi
callq 0x2060
movl %eax, %r13d
testl %eax, %eax
jne 0x5531
movq 0x28(%r14), %rax
movq (%rax,%rbx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x554a
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21b0
testl %r13d, %r13d
je 0x5571
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
incq %rbx
sarq $0x5, %rax
addq $0x20, %r15
cmpq %rbx, %rax
ja 0x54ff
jmp 0x5571
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x55a0
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/utils.cpp
// Function: writeNBytes(int, void const*, unsigned long, int)
ssize_t writeNBytes(int fd, const void *buf, size_t nbyte, int isNonBlocking) {
    size_t hasWritten = 0;
    const char* src = (const char*)buf;
    

    while(hasWritten < nbyte) {
        ssize_t tempLen = send(fd, src + hasWritten, nbyte - hasWritten, 0);
        if(tempLen < 0) {
            if (isNonBlocking && errno == EAGAIN) {
                continue;
            }
            LogHelper::log(Error, "Errors when write fd, fd: %d, %s", fd, strerror(errno));
            return -1;
        }
        if (isNonBlocking && tempLen == 0) {
            LogHelper::log(Error, "Connection has been closed in sockFd %d when tried to send", fd);
            return hasWritten;
        }
        hasWritten += tempLen;
    }
    return hasWritten;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x596c
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %ebx
xorl %r14d, %r14d
leaq (%r12,%r14), %rsi
movq %r15, %rdx
subq %r14, %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x2100
testq %rax, %rax
js 0x5957
testl %ebp, %ebp
je 0x5952
testq %rax, %rax
je 0x5996
addq %rax, %r14
jmp 0x5965
callq 0x2040
testl %ebp, %ebp
je 0x5971
cmpl $0xb, (%rax)
jne 0x5971
cmpq %r15, %r14
jb 0x5931
jmp 0x59a8
xorl %r14d, %r14d
jmp 0x59a8
movl (%rax), %edi
callq 0x20d0
leaq 0x2132(%rip), %rsi      # 0x7ab1
xorl %edi, %edi
movl %ebx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x273c
movq $-0x1, %r14
jmp 0x59a8
leaq 0x2135(%rip), %rsi      # 0x7ad2
xorl %edi, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x273c
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/aes.cpp
// Function: GLOBAL__sub_I_aes.cpp
static void subBytes(int (&array)[4][4]){
	int i,j;
	for(i = 0; i < 4; i++)
		for(j = 0; j < 4; j++)
			array[i][j] = getNumFromBox(S, array[i][j]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0xb9ef6(%rip), %rax     # 0xbc4b0
movq %rax, 0xb9edf(%rip)     # 0xbc4a0
leaq 0xb9ed8(%rip), %rsi     # 0xbc4a0
movabsq $0x2e302e302e373231, %r15 # imm = 0x2E302E302E373231
movq %r15, 0xb9ed7(%rip)     # 0xbc4b0
movw $0x31, %bp
movw %bp, 0xb9ed4(%rip)      # 0xbc4b8
movl $0x9, %r12d
movq %r12, 0xb9eb7(%rip)     # 0xbc4a8
movq 0x99c8(%rip), %rbx      # 0xbfc0
leaq 0x9bb1(%rip), %r14      # 0xc1b0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2180
leaq 0xb9ebf(%rip), %rax     # 0xbc4d0
movq %rax, 0xb9ea8(%rip)     # 0xbc4c0
leaq 0xb9ea1(%rip), %rsi     # 0xbc4c0
movq %r15, 0xb9eaa(%rip)     # 0xbc4d0
movw %bp, 0xb9eab(%rip)      # 0xbc4d8
movq %r12, 0xb9e94(%rip)     # 0xbc4c8
movq %rbx, %rdi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2180
nopw (%rax,%rax)
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/loghelper.cpp
// Function: LogHelper::log(LogType, char const*, ...)
void LogHelper::log(LogType type, const char * format, ...) {
#ifdef LOG_TRACE
    if(type <= Trace)
#elif defined LOG_DEBUG
    if(type <= Debug)
#elif defined LOG_INFO
    if(type <= Info)
#elif defined LOG_WARN
    if(type <= Warn)
#endif
    {
        va_list args;
        if (type == Error) {
            fprintf(stderr, "\033[40;31m");
        }
        else if (type == Warn) {
            fprintf(stderr, "\033[40;33m");
        }
        va_start(args, format);
        vfprintf(stderr, format, args);
        va_end(args);
        if (type == Error || type == Warn) {
            fprintf(stderr, "\033[0m");
        }
        fprintf(stderr, "\n");
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x2797
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)
cmpl $0x2, %edi
jle 0x27a9
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rsi, %r14
movl %edi, %ebx
testl %edi, %edi
je 0x27c0
cmpl $0x1, %ebx
jne 0x27cc
leaq 0x484f(%rip), %rdi      # 0x700d
jmp 0x27c7
leaq 0x483d(%rip), %rdi      # 0x7004
callq 0x2360
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq 0x97e0(%rip), %r15      # 0xbfd8
movq (%r15), %rdi
movq %r14, %rsi
callq 0x2270
cmpl $0x1, %ebx
jbe 0x2817
movq (%r15), %rsi
movl $0xa, %edi
callq 0x2220
jmp 0x279c
callq 0x2375
jmp 0x2808
nop
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/proxyserver.cpp
// Function: sendData(int, unsigned char const*, unsigned long, std::unordered_map<int, ClientNode*, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, ClientNode*>>>&, int)
int sendData(int sockFd, const uint8_t *data, size_t nbyte, ClientMap &cMap, int msgType = 5) {
    ClientNode *node = cMap[sockFd];
    static InnerMsg innerMsg;
    memset(&innerMsg, 0, sizeof(innerMsg));
    node->sSeq++;
    
    innerMsg.cSeq = node->cSeq;
    innerMsg.sSeq = node->sSeq;
    innerMsg.msgType = msgType;
    if (nbyte > sizeof(innerMsg.data)) {
        LogHelper::log(Error, "Failed to send data, nbyte too large, nbyte: %lu", nbyte);
        return -1;
    }
    innerMsg.dataLength = nbyte;
    memcpy(innerMsg.data, data, nbyte);
    ssize_t sendCode = sendTSPacket(sockFd, &innerMsg, constants::serverNonBlocking);
    if (sendCode < 0) {
        LogHelper::log(Error, "Fail to send data");
        return sendCode;
    }
    node->lastTime = time(NULL);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0xc(%rsp), %rsi
movl %edi, (%rsi)
movq %rcx, %rdi
callq 0x48c8
movq (%rax), %r12
leaq 0x197d1(%rip), %rdi     # 0x1c210
movl $0x10000, %edx          # imm = 0x10000
xorl %esi, %esi
callq 0x2120
movq (%r12), %rax
movq 0x8(%r12), %rcx
incq %rcx
movq %rcx, 0x8(%r12)
movq %rax, 0x197ad(%rip)     # 0x1c210
movq %rcx, 0x197ae(%rip)     # 0x1c218
movw %bp, 0x197af(%rip)      # 0x1c220
cmpq $0xffed, %rbx           # imm = 0xFFED
jb 0x2a94
leaq 0x474d(%rip), %rsi      # 0x71ce
xorl %edi, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x273c
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x2aed
movw %bx, 0x19787(%rip)      # 0x1c222
leaq 0x1976e(%rip), %r15     # 0x1c210
leaq 0x1977b(%rip), %rdi     # 0x1c224
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2150
movl 0xc(%rsp), %edi
movq %r15, %rsi
movl $0x1, %edx
callq 0x5cd7
testq %rax, %rax
js 0x2ada
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x2190
movq %rax, 0x10(%r12)
jmp 0x2aed
movq %rax, %rbx
leaq 0x471b(%rip), %rsi      # 0x71ff
xorl %edi, %edi
xorl %eax, %eax
callq 0x273c
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/proxyserver.cpp
// Function: eraseHostFromFdSets(int, fd_set&, fd_set&, int&, int&, int&)
void eraseHostFromFdSets(int hostFd, fd_set &readSet, fd_set &writeSet, int &max_read_sd, int &max_write_sd, int &max_all_sd) {
    
    if (FD_ISSET(hostFd, &writeSet)) {
        close(hostFd);
        FD_CLR(hostFd, &writeSet);
        if (hostFd == max_write_sd) {
            while (FD_ISSET(max_write_sd, &writeSet) == 0 && max_write_sd > 0)
                max_write_sd -= 1;
        }
    }
    else {
        LogHelper::log(Warn, "hostFd :%d not in writeSet");
    }
    if (FD_ISSET(hostFd, &readSet)) {
        FD_CLR(hostFd, &readSet);
        if (hostFd == max_read_sd) {
            while (FD_ISSET(max_read_sd, &readSet) == 0)
                max_read_sd -= 1;
        }
    }
    else {
        LogHelper::log(Warn, "hostFd: %d not in readSet");
    }
    
    max_all_sd = std::max(max_read_sd, max_write_sd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r14
movq %rcx, (%rsp)
movl %edi, %r12d
leal 0x3f(%r12), %eax
testl %edi, %edi
cmovnsl %edi, %eax
movq %rsi, %r13
movl %eax, %ecx
sarl $0x6, %ecx
movslq %ecx, %rbx
andl $-0x40, %eax
movl %edi, %ecx
subl %eax, %ecx
movl $0x1, %r15d
shlq %cl, %r15
movq (%rdx,%rbx,8), %rax
btq %rcx, %rax
movq %r15, 0x8(%rsp)
notq %r15
jae 0x326a
movq %rdx, %rbp
movl %r12d, %edi
callq 0x2340
andq %r15, (%rbp,%rbx,8)
cmpl %r12d, (%r14)
jne 0x327d
movl %r12d, %eax
leal 0x3f(%rax), %edx
testl %eax, %eax
cmovnsl %eax, %edx
movl %edx, %esi
andl $-0x40, %esi
movl %eax, %ecx
subl %esi, %ecx
movl $0x1, %esi
shlq %cl, %rsi
testl %eax, %eax
jle 0x327d
sarl $0x6, %edx
movslq %edx, %rcx
andq (%rbp,%rcx,8), %rsi
jne 0x327d
decl %eax
movl %eax, (%r14)
jmp 0x3239
leaq 0x4332(%rip), %rsi      # 0x75a3
movl $0x1, %edi
xorl %eax, %eax
callq 0x273c
movq (%r13,%rbx,8), %rax
testq %rax, 0x8(%rsp)
je 0x32c5
andq %r15, %rax
movq %rax, (%r13,%rbx,8)
movq (%rsp), %rcx
movl (%rcx), %eax
cmpl %r12d, %eax
jne 0x32de
movl %r12d, %eax
leal -0x1(%rax), %r12d
addl $0x3e, %eax
testl %r12d, %r12d
cmovnsl %r12d, %eax
sarl $0x6, %eax
cltq
movq (%r13,%rax,8), %rax
btq %r12, %rax
jae 0x329c
movl %r12d, (%rcx)
movl %r12d, %eax
jmp 0x32de
leaq 0x42f2(%rip), %rsi      # 0x75be
movl $0x1, %edi
xorl %eax, %eax
callq 0x273c
movq (%rsp), %rax
movl (%rax), %eax
movl (%r14), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/proxyserver.cpp
// Function: eraseClientFromFdSet(int, fd_set&, int&, int, int&)
void eraseClientFromFdSet(int clientFd, fd_set &readSet, int &max_read_sd, int max_write_sd, int &max_all_sd) {
    close(clientFd);
    FD_CLR(clientFd, &readSet);
    if (clientFd == max_read_sd) {
        while (FD_ISSET(max_read_sd, &readSet) == 0)
            max_read_sd -= 1;
    }
    max_all_sd = std::max(max_read_sd, max_write_sd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r12d
callq 0x2340
movq $-0x2, %rax
movl %r12d, %ecx
rolq %cl, %rax
leal 0x3f(%r12), %ecx
testl %r12d, %r12d
cmovnsl %r12d, %ecx
sarl $0x6, %ecx
movslq %ecx, %rcx
andq %rax, (%r15,%rcx,8)
movl (%r14), %eax
cmpl %r12d, %eax
jne 0x3368
movl %r12d, %eax
leal -0x1(%rax), %r12d
addl $0x3e, %eax
testl %r12d, %r12d
cmovnsl %r12d, %eax
sarl $0x6, %eax
cltq
movq (%r15,%rax,8), %rax
btq %r12, %rax
jae 0x3342
movl %r12d, (%r14)
movl %r12d, %eax
cmpl %ebp, %eax
cmovgl %eax, %ebp
movl %ebp, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/proxyserver.cpp
// Function: cleanDeadLocalFds(int, std::unordered_map<int, HostNode, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, HostNode>>>&, std::unordered_map<int, SocketNode, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, SocketNode>>>&, fd_set&, fd_set&, int&, int&, int&, bool)
void cleanDeadLocalFds(int clientFd, HostMap &h2lMap, SocketMap &sMap, fd_set &readSet, fd_set &writeSet, int &max_read_sd, int &max_write_sd, int &max_all_sd, bool forceClean = false) {
    time_t now = time(NULL);
    for (auto it = sMap.begin(); it != sMap.end();) {
        if (forceClean || now - it->second.lastTime > constants::SocketTimeOutSeconds) {
            int localFd = it->first, hostFd = it->second.sockFd;
            LogHelper::log(Debug, "Clean timeout localFd %d in clientFd: %d, forceClean: %d", localFd, clientFd, forceClean);
            eraseHostFromFdSets(hostFd, readSet, writeSet, max_read_sd, max_write_sd, max_all_sd);
            h2lMap.erase(hostFd);
            it = sMap.erase(it);
            
        }
        else it++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movl %edi, %ebp
xorl %edi, %edi
callq 0x2190
movq %rax, 0x10(%rsp)
movq 0x10(%r12), %rbx
testq %rbx, %rbx
je 0x343a
movzbl 0x70(%rsp), %r14d
cmpb $0x0, 0x70(%rsp)
jne 0x33d3
movq 0x10(%rsp), %rax
subq 0x18(%rbx), %rax
cmpq $0xb5, %rax
jl 0x3432
movl 0x8(%rbx), %edx
movl 0x10(%rbx), %eax
movl %eax, 0xc(%rsp)
movl $0x3, %edi
leaq 0x41ef(%rip), %rsi      # 0x75d8
movl %ebp, %ecx
movl %r14d, %r8d
xorl %eax, %eax
callq 0x273c
movl 0xc(%rsp), %edi
movq %r15, %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x60(%rsp), %r8
movq 0x68(%rsp), %r9
callq 0x31cd
movq %r13, %rdi
leaq 0xc(%rsp), %rsi
callq 0x517a
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5270
movq %rax, %rbx
jmp 0x3435
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x33bb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq