LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/App.cpp
// Function: App::App()
App::App()
{
    if (SDL_Init(SDL_INIT_EVERYTHING) != 0 ) {
        std::cout << "Unable initialize SDL: " << SDL_GetError();
        return;
    }
    win = new Window("Asteroids");
    rend = new Renderer(win->getWin());

    nextFrameTime = SDL_GetTicks();
    srand(time(NULL));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rbx, %rdi
callq 0x2de8
movb $0x1, 0xd8(%r14)
movaps 0x29d1(%rip), %xmm0     # 0x5010
movups %xmm0, 0x118(%r14)
movl $0x5, 0x128(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x12c(%r14)
movl $0x0, 0x13c(%r14)
movl $0xf231, %edi           # imm = 0xF231
callq 0x2250
testl %eax, %eax
je 0x26c1
movq 0x595b(%rip), %r14      # 0x7fd8
leaq 0x29b0(%rip), %rsi      # 0x5034
movl $0x17, %edx
movq %r14, %rdi
callq 0x2300
callq 0x2210
movq %rax, %r15
testq %rax, %rax
je 0x2779
movq %r15, %rdi
callq 0x2160
movq 0x5927(%rip), %rdi      # 0x7fd8
movq %r15, %rsi
movq %rax, %rdx
callq 0x2300
jmp 0x2791
movl $0x8, %edi
callq 0x22c0
movq %rax, %r15
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x296e(%rip), %rsi      # 0x504c
leaq 0x2970(%rip), %rdx      # 0x5055
leaq -0x40(%rbp), %rdi
callq 0x2ba2
movq $0x0, (%r15)
movq -0x40(%rbp), %rdi
movl $0x2fff0000, %esi       # imm = 0x2FFF0000
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
movl $0x320, %ecx            # imm = 0x320
movl $0x258, %r8d            # imm = 0x258
movl $0x4, %r9d
callq 0x2080
movq %rax, (%r15)
movq %r15, (%r14)
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x272d
callq 0x2290
movl $0x8, %edi
callq 0x22c0
movq %rax, %r15
movq (%r14), %rax
movq (%rax), %rdi
movq $0x0, (%r15)
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x2, %edx
callq 0x2070
movq %rax, (%r15)
movq %r15, 0x8(%r14)
callq 0x22d0
movl %eax, 0x130(%r14)
xorl %edi, %edi
callq 0x2270
movl %eax, %edi
callq 0x22a0
jmp 0x2791
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2390
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27b3
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x27b6
callq 0x2290
jmp 0x27b6
movq %rax, %r14
movq %r15, %rdi
callq 0x2290
jmp 0x27c3
movq %rax, %r14
movq %rbx, %rdi
callq 0x32a6
movq %r14, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/App.cpp
// Function: App::execute()
int App::execute()
{
    while (running) {
        if (SDL_GetTicks() > dataOutputTimer + 1000) {
            dataOutputTimer = SDL_GetTicks();
        }

        if (SDL_GetTicks() > rockSpawnTimer + 15000) {
            game.spawnRock(BIG_ROCK, 1);
            rockSpawnTimer = SDL_GetTicks();
        }

        this->inputs();

        loops = 0;
        deltaTime = float(SDL_GetTicks() - prevFrameTime) / 1000.0f;

        while (SDL_GetTicks() > nextFrameTime && loops < maxFrameSkip) {
            game.updatePositions(deltaTime);

            nextFrameTime += singleFrameTimeInMS;
            prevFrameTime = SDL_GetTicks();
            loops++;
        }
        interpolation = float(SDL_GetTicks() + singleFrameTimeInMS - nextFrameTime) / float(singleFrameTimeInMS);
        game.collisions();
        if (true) {
            game.interpolate(deltaTime, interpolation);
            game.draw(rend);
        }
    }
    return 0;
}

// Assembly:
cmpb $0x1, 0xd8(%rdi)
jne 0x29b9
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq 0x118(%rdi), %r15
leaq 0x11c(%rdi), %r12
xorl %r13d, %r13d
callq 0x22d0
movl 0x138(%rbx), %ecx
movl $0x3e8, %edx            # imm = 0x3E8
addl %edx, %ecx
cmpl %ecx, %eax
jbe 0x2885
callq 0x22d0
movl %eax, 0x138(%rbx)
callq 0x22d0
movl 0x13c(%rbx), %ecx
movl $0x3a98, %edx           # imm = 0x3A98
addl %edx, %ecx
cmpl %ecx, %eax
jbe 0x28d4
movl $0x259, -0x38(%rbp)     # imm = 0x259
movl $0x1, -0x34(%rbp)
movl %r13d, -0x30(%rbp)
movl %r13d, -0x2c(%rbp)
movq %r14, %rdi
leaq -0x38(%rbp), %rsi
leaq -0x34(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x2c(%rbp), %r8
callq 0x2e7e
callq 0x22d0
movl %eax, 0x13c(%rbx)
movq %rbx, %rdi
callq 0x29bc
movl $0x0, 0x12c(%rbx)
callq 0x22d0
subl 0x134(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
divss 0x272f(%rip), %xmm0     # 0x5030
movss %xmm0, 0x118(%rbx)
callq 0x22d0
cmpl 0x130(%rbx), %eax
jbe 0x294e
movl 0x12c(%rbx), %eax
cmpl 0x128(%rbx), %eax
jge 0x294e
movq %r14, %rdi
movq %r15, %rsi
callq 0x35e2
movl 0x124(%rbx), %eax
addl %eax, 0x130(%rbx)
callq 0x22d0
movl %eax, 0x134(%rbx)
incl 0x12c(%rbx)
jmp 0x2909
callq 0x22d0
movl 0x124(%rbx), %ecx
addl %ecx, %eax
subl 0x130(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x11c(%rbx)
movq %r14, %rdi
callq 0x3380
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3634
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x368c
cmpb $0x0, 0xd8(%rbx)
jne 0x2864
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/Bullet.cpp
// Function: Bullet::Bullet(SDL_Point, float const&, float const&, int const&, int const&)
Bullet::Bullet(SDL_Point p, const float& vX, const float& vY, const int& t, const int& n)
: num(n), type(t), dead(false)
{
    position = {p.x, p.y};
    prevPosition = {p.x, p.y};
    if (type == BULLET) {

    }

    velocity[0] = vX;
    velocity[1] = vY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rax
shrq $0x20, %rax
xorl %r10d, %r10d
movl %r10d, 0x18(%rdi)
movq $0x0, 0x24(%rdi)
leaq 0x5023(%rip), %r11      # 0x7c80
movq %r11, (%rdi)
movl %r10d, 0x2c(%rdi)
movl (%r9), %r9d
movl %r9d, 0x30(%rdi)
movl %r10d, 0x34(%rdi)
movl (%r8), %r8d
movl %r8d, 0x38(%rdi)
movb $0x0, 0x3c(%rdi)
movl %esi, 0x10(%rdi)
movl %eax, 0x14(%rdi)
movl %esi, 0x8(%rdi)
movl %eax, 0xc(%rdi)
movss (%rdx), %xmm0
movss %xmm0, 0x1c(%rdi)
movss (%rcx), %xmm0
movss %xmm0, 0x20(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/Bullet.cpp
// Function: Bullet::updatePosition(float const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Bullet, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Bullet>>>&)
void Bullet::updatePosition(const float& dT, std::map<std::string, Bullet>& m)
{
    position.x = prevPosition.x - velocity[0] * dT;
    position.y = prevPosition.y - velocity[1] * dT;

    if (position.x > 800) {
        position.x -= 800;
    } else if (position.x < 0) {
        position.x += 800;
    }
    if (position.y > 600) {
        position.y -= 600;
    } else if (position.y < 0) {
        position.y += 600;
    }

    if (type == BULLET) {
        if (life > 25) {
            dead = true;
        } else {
            life++;
        }
    }

    prevPosition.x = position.x;
    prevPosition.y = position.y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cvtsi2ssl 0x8(%rdi), %xmm0
movss (%rsi), %xmm1
movss 0x1c(%rdi), %xmm2
mulss %xmm1, %xmm2
subss %xmm2, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, 0x10(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0xc(%rdi), %xmm0
mulss 0x20(%rdi), %xmm1
subss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x14(%rdi)
movl $0xfffffce0, %edx       # imm = 0xFFFFFCE0
cmpl $0x320, %ecx            # imm = 0x320
jg 0x2cef
testl %ecx, %ecx
jns 0x2cf4
movl $0x320, %edx            # imm = 0x320
addl %ecx, %edx
movl %edx, 0x10(%rdi)
movl $0xfffffda8, %ecx       # imm = 0xFFFFFDA8
cmpl $0x258, %eax            # imm = 0x258
jg 0x2d09
testl %eax, %eax
jns 0x2d0e
movl $0x258, %ecx            # imm = 0x258
addl %eax, %ecx
movl %ecx, 0x14(%rdi)
cmpl $0x25c, 0x38(%rdi)      # imm = 0x25C
jne 0x2d2a
movl 0x2c(%rdi), %eax
cmpl $0x1a, %eax
jl 0x2d25
movb $0x1, 0x3c(%rdi)
jmp 0x2d2a
incl %eax
movl %eax, 0x2c(%rdi)
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/Bullet.cpp
// Function: Bullet::draw(SDL_Renderer*)
void Bullet::draw(SDL_Renderer* r)
{
    if (type == BULLET) {
        SDL_SetRenderDrawColor(r, 0, 255, 0, 1.0);
        SDL_RenderDrawPoint(r, position.x, position.y);
        SDL_SetRenderDrawColor(r, 0, 0, 0, 255);
    }
}

// Assembly:
cmpl $0x25c, 0x38(%rdi)      # imm = 0x25C
jne 0x2dd1
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
xorl %esi, %esi
movl $0xff, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x2320
movl 0x10(%r14), %esi
movl 0x14(%r14), %edx
movq %rbx, %rdi
callq 0x2260
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0xff, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x2320
retq
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/GameEngine.cpp
// Function: GameEngine::actionShip(int const&, bool)
void GameEngine::actionShip(const int& action, bool down)
{
    if (down) {
        if (player.isAlive()) {
            switch (action) {
            case GameEngine::UP:
                player.thrusting(true);
                break;
            case GameEngine::LEFT:
                player.rotate(Ship::LEFT);
                break;
            case GameEngine::RIGHT:
                player.rotate(Ship::RIGHT);
                break;
            case GameEngine::FIRE:
                if (player.isLoaded()) {
                    player.fire();
                    player.loaded(false);
                }
                break;
            }
        }
    } else {
        switch (action) {
        case GameEngine::UP:
            player.thrusting(false);
            break;
        case GameEngine::LEFT:
            player.rotate(Ship::NONE);
            break;
        case GameEngine::RIGHT:
            player.rotate(Ship::NONE);
            break;
        case GameEngine::FIRE:
            player.loaded(true);
            break;
        case GameEngine::ALIVE:
            player.setAlive(true);
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %edx, %edx
je 0x3309
cmpb $0x1, 0x88(%rbx)
jne 0x3378
movl (%rsi), %eax
cmpq $0x3, %rax
ja 0x3378
leaq 0x1dbd(%rip), %rcx      # 0x50b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, 0x89(%rbx)
jmp 0x3378
movl (%rsi), %eax
cmpq $0x4, %rax
ja 0x3378
leaq 0x1d88(%rip), %rcx      # 0x50a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, 0x80(%rbx)
jmp 0x3378
movb $0x1, 0x88(%rbx)
jmp 0x3378
movb $0x0, 0x89(%rbx)
jmp 0x3378
movb $0x1, 0x8a(%rbx)
jmp 0x3378
movl $0x2, 0x80(%rbx)
jmp 0x3378
cmpb $0x1, 0x8a(%rbx)
jne 0x3378
movq %rbx, %rdi
callq 0x476e
movb $0x0, 0x8a(%rbx)
jmp 0x3378
movl $0x1, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/GameEngine.cpp
// Function: GameEngine::updatePositions(float const&)
void GameEngine::updatePositions(const float& deltaTime)
{
    player.updatePosition(deltaTime);

    for (auto rock = rocks.begin(); rock != rocks.end(); rock++) {
        Rock& currentRock = rock->second;
        currentRock.updatePosition(deltaTime);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x446e
movq 0xa8(%r14), %r15
addq $0x98, %r14
cmpq %r14, %r15
je 0x3628
leaq 0x40(%r15), %rdi
movq 0x40(%r15), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq %r15, %rdi
callq 0x21c0
movq %rax, %r15
cmpq %r14, %rax
jne 0x360a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/GameEngine.cpp
// Function: GameEngine::interpolate(float const&, float const&)
void GameEngine::interpolate(const float& deltaTime, const float& interpolation)
{
    player.interpolate(deltaTime, interpolation);

    for (auto rock = rocks.begin(); rock != rocks.end(); rock++) {
        Rock& currentRock = rock->second;
        currentRock.interpolate(deltaTime, interpolation);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4608
movq 0xa8(%r15), %r12
addq $0x98, %r15
cmpq %r15, %r12
je 0x3683
leaq 0x40(%r12), %rdi
movq 0x40(%r12), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
movq %r12, %rdi
callq 0x21c0
movq %rax, %r12
cmpq %r15, %rax
jne 0x3660
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/GameEngine.cpp
// Function: GameEngine::draw(Renderer*)
void GameEngine::draw(Renderer *rend)
{
    rend->clear();
    player.draw(rend->getRend());

    for (auto rock = rocks.begin(); rock != rocks.end(); rock++) {
        Rock& currentRock = rock->second;
        currentRock.draw(rend->getRend());
    }

    rend->present();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0xff, %r8d
callq 0x2320
movq (%rbx), %rdi
callq 0x2280
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x46bc
movq 0xa8(%r14), %r15
addq $0x98, %r14
cmpq %r14, %r15
je 0x36f4
leaq 0x40(%r15), %rdi
movq (%rbx), %rsi
movq 0x40(%r15), %rax
callq *0x18(%rax)
movq %r15, %rdi
callq 0x21c0
movq %rax, %r15
cmpq %r14, %rax
jne 0x36d6
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/Rock.cpp
// Function: Rock::Rock(SDL_Point, float const&, float const&, int const&, int const&)
Rock::Rock(SDL_Point p, const float& vX, const float& vY, const int& t, const int& n)
: num(n), type(t)
{
    position = {p.x, p.y};
    prevPosition = {p.x, p.y};
    angle = (rand() % 314) / 100;
    if (num % 2 == 0) {
        angleVel = 0.01;
    } else {
        angleVel = -0.01;
    }

    velocity[0] = vX;
    velocity[1] = vY;

    color = {Uint8(rand() % 255), Uint8(rand() % 255), Uint8(rand() % 255)};

    generateDeviation();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x20, %rax
xorl %r12d, %r12d
movl %r12d, 0x18(%rdi)
movq $0x0, 0x24(%rdi)
leaq 0x41a7(%rip), %rcx      # 0x7d20
movq %rcx, (%rdi)
movl %r12d, 0x2c(%rdi)
movl (%r9), %ecx
movl %ecx, 0x30(%rdi)
movl (%r8), %ecx
movl %ecx, 0x34(%rdi)
movl %r12d, 0x98(%rdi)
movl %esi, 0x10(%rdi)
movl %eax, 0x14(%rdi)
movl %esi, 0x8(%rdi)
movl %eax, 0xc(%rdi)
callq 0x2110
cltq
imulq $0x342da7f3, %rax, %rcx # imm = 0x342DA7F3
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
sarl $0x6, %ecx
addl %edx, %ecx
imull $0x13a, %ecx, %ecx      # imm = 0x13A
subl %ecx, %eax
cltq
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
sarl $0x5, %eax
addl %ecx, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x18(%rbx)
xorl %eax, %eax
testb $0x1, 0x30(%rbx)
sete %al
leaq 0x14d9(%rip), %rcx      # 0x50d0
movss (%rcx,%rax,4), %xmm0
movss %xmm0, 0x98(%rbx)
movss (%r15), %xmm0
movss %xmm0, 0x1c(%rbx)
movss (%r14), %xmm0
movss %xmm0, 0x20(%rbx)
callq 0x2110
cltq
imulq $-0x7f7f7f7f, %rax, %r14 # imm = 0x80808081
shrq $0x20, %r14
addl %eax, %r14d
movl %r14d, %ecx
shrl $0x1f, %ecx
shrl $0x7, %r14d
addl %ecx, %r14d
addl %eax, %r14d
callq 0x2110
cltq
imulq $-0x7f7f7f7f, %rax, %r15 # imm = 0x80808081
shrq $0x20, %r15
addl %eax, %r15d
movl %r15d, %ecx
shrl $0x1f, %ecx
shrl $0x7, %r15d
addl %ecx, %r15d
addl %eax, %r15d
callq 0x2110
cltq
imulq $-0x7f7f7f7f, %rax, %rcx # imm = 0x80808081
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
shrl $0x7, %ecx
addl %edx, %ecx
addl %eax, %ecx
movb %r14b, 0x38(%rbx)
movb %r15b, 0x39(%rbx)
movb %cl, 0x3a(%rbx)
movb $0x0, 0x3b(%rbx)
callq 0x2110
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x1418(%rip), %xmm0     # 0x50d8
mulsd 0x1418(%rip), %xmm0     # 0x50e0
addsd 0x1418(%rip), %xmm0     # 0x50e8
movsd %xmm0, 0x40(%rbx,%r12,8)
incq %r12
cmpq $0xa, %r12
jne 0x3c91
movsd 0x40(%rbx), %xmm0
movsd %xmm0, 0x90(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/Rock.cpp
// Function: Rock::generateDeviation()
void Rock::generateDeviation() {
    double deviationDelta = (ROCK_DEVIATION_MAX - ROCK_DEVIATION_MIN);
    for (int part = 0; part < ROCK_PARTS; part++) {
        double deviation = ROCK_DEVIATION_MIN + deviationDelta * ((rand() % 100) / 100.0);
        this -> deviation[part] = deviation;
    }
    this -> deviation[ROCK_PARTS] = deviation[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
callq 0x2110
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x13a6(%rip), %xmm0     # 0x50d8
mulsd 0x13a6(%rip), %xmm0     # 0x50e0
addsd 0x13a6(%rip), %xmm0     # 0x50e8
movsd %xmm0, 0x40(%rbx,%r14,8)
incq %r14
cmpq $0xa, %r14
jne 0x3d03
movsd 0x40(%rbx), %xmm0
movsd %xmm0, 0x90(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/Rock.cpp
// Function: Rock::generate(int, double)
void Rock::generate(int radius, double rotAngle) {
    for (int part = 0; part <= ROCK_PARTS; part++) {
        double angle = part * 2 * M_PI / ROCK_PARTS + rotAngle;
        double deviation = this -> deviation[part];
        int px = int(cos(angle) * radius * deviation) + position.x;
        int py = int(sin(angle) * radius * deviation) + position.y;
        lines[part].x = px;
        lines[part].y = py;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
movsd %xmm0, -0x20(%rbp)
movq %rdi, %rbx
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
mulsd 0x1328(%rip), %xmm0     # 0x50f0
divsd 0x1328(%rip), %xmm0     # 0x50f8
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x40(%rbx,%r14,4), %xmm1
movsd %xmm1, -0x28(%rbp)
callq 0x23d0
mulsd -0x20(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
cvttsd2si %xmm0, %r15d
addl 0x10(%rbx), %r15d
movsd -0x38(%rbp), %xmm0
callq 0x20e0
mulsd -0x20(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
cvttsd2si %xmm0, %eax
addl 0x14(%rbx), %eax
movl %r15d, 0x9c(%rbx,%r14,4)
movl %eax, 0xa0(%rbx,%r14,4)
addq $0x2, %r14
cmpq $0x16, %r14
jne 0x3db8
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/Rock.cpp
// Function: Rock::updatePosition(float const&)
void Rock::updatePosition(const float& dT)
{
    position.x = prevPosition.x - velocity[0] * dT;
    position.y = prevPosition.y - velocity[1] * dT;

    if (position.x > 800) {
        position.x -= 800;
    } else if (position.x < 0) {
        position.x += 800;
    }
    if (position.y > 600) {
        position.y -= 600;
    } else if (position.y < 0) {
        position.y += 600;
    } else if (position.x == 0 || position.y == 0) {
        position.x -= 20;
        position.y -= 20;
    }

    angle += angleVel;

    prevPosition.x = position.x;
    prevPosition.y = position.y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cvtsi2ssl 0x8(%rdi), %xmm0
movss (%rsi), %xmm1
movss 0x1c(%rdi), %xmm2
mulss %xmm1, %xmm2
subss %xmm2, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, 0x10(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0xc(%rdi), %xmm0
mulss 0x20(%rdi), %xmm1
subss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x14(%rdi)
movl $0xfffffce0, %edx       # imm = 0xFFFFFCE0
cmpl $0x320, %ecx            # imm = 0x320
jg 0x3e8d
testl %ecx, %ecx
jns 0x3e92
movl $0x320, %edx            # imm = 0x320
addl %ecx, %edx
movl %edx, 0x10(%rdi)
movl $0xfffffda8, %ecx       # imm = 0xFFFFFDA8
cmpl $0x258, %eax            # imm = 0x258
jg 0x3ec7
testl %eax, %eax
js 0x3ec2
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
setne %dl
testl %eax, %eax
setne %sil
testb %dl, %sil
jne 0x3ecc
addl $-0x14, %ecx
movl %ecx, 0x10(%rdi)
movl $0xffffffec, %ecx       # imm = 0xFFFFFFEC
jmp 0x3ec7
movl $0x258, %ecx            # imm = 0x258
addl %eax, %ecx
movl %ecx, 0x14(%rdi)
movss 0x98(%rdi), %xmm0
addss 0x18(%rdi), %xmm0
movss %xmm0, 0x18(%rdi)
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/Ship.cpp
// Function: Ship::Ship()
Ship::Ship()
{
    prevPosition = {400, 300};
    position = {400, 300};
    ship = new SDL_Point[5];
    thruster = new SDL_Point[3];
    colPoints = new SDL_Rect[3];
    coefArr = readConfig("config/Ship.txt");

    velocity[0] = 0.0;
    velocity[1] = 0.0;

    this->trace();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0x18(%rdi)
movq %rax, 0x24(%rdi)
leaq 0x3dc0(%rip), %rcx      # 0x7d68
movq %rcx, (%rdi)
leaq 0x48(%rdi), %rcx
movl %eax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movq %rcx, 0x58(%rdi)
movq %rcx, 0x60(%rdi)
movups %xmm0, 0x68(%rdi)
movups %xmm0, 0x78(%rdi)
movw $0x1, 0x88(%rdi)
movb $0x1, 0x8a(%rdi)
movl %eax, 0x8c(%rdi)
movaps 0x1136(%rip), %xmm0     # 0x5120
movups %xmm0, 0x8(%rdi)
movl $0x28, %edi
callq 0x2040
movq %rax, 0x70(%rbx)
movl $0x18, %edi
callq 0x2040
movq %rax, 0x78(%rbx)
movl $0x30, %edi
callq 0x2040
movq %rax, 0x38(%rbx)
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1129(%rip), %rsi      # 0x5150
leaq 0x1131(%rip), %rdx      # 0x515f
leaq -0x38(%rbp), %rdi
callq 0x2ba2
leaq -0x38(%rbp), %rsi
callq 0x409c
leaq 0x30(%rbx), %rcx
movq %rax, (%rcx)
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4055
callq 0x2290
movq $0x0, 0x1c(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4088
callq 0x2290
jmp 0x4088
jmp 0x4085
movq %rax, %r14
addq $0x40, %rbx
movq %rbx, %rdi
callq 0x4aae
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/Ship.cpp
// Function: Ship::readConfig(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int** Ship::readConfig(const std::string& filename)
{
    std::ifstream config (filename);
    if (config.is_open()) {
        int countM;
        int countN;
        config >> countM;
        config >> countN;
        int **arr = new int*[countM];
        for (int i = 0; i < countM; i++) {
            arr[i] = new int[countN];
            for (int j = 0; j < countN; j++) {
                config >> arr[i][j];
            }
        }
        config.close();
        return arr;
    } else {
        std::cout << "Error: Not found config file at " << filename << std::endl;
        return nullptr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %rbx
leaq -0x238(%rbp), %rdi
movl $0x8, %edx
callq 0x2370
leaq -0x1c0(%rbp), %rdi
callq 0x20f0
testb %al, %al
je 0x418e
leaq -0x238(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2190
leaq -0x238(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2190
movslq -0x30(%rbp), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2040
movq %rax, %rbx
cmpl $0x0, -0x30(%rbp)
jle 0x4180
xorl %r12d, %r12d
leaq -0x238(%rbp), %r14
movslq -0x2c(%rbp), %rax
leaq (,%rax,4), %rdi
testq %rax, %rax
movq $-0x1, %rax
cmovsq %rax, %rdi
callq 0x2040
movq %rax, %r15
movq %rax, (%rbx,%r12,8)
cmpl $0x0, -0x2c(%rbp)
jle 0x4174
xorl %r13d, %r13d
movq %r14, %rdi
movq %r15, %rsi
callq 0x2190
incq %r13
movslq -0x2c(%rbp), %rax
addq $0x4, %r15
cmpq %rax, %r13
jl 0x4159
incq %r12
movslq -0x30(%rbp), %rax
cmpq %rax, %r12
jl 0x412a
leaq -0x238(%rbp), %rdi
callq 0x20d0
jmp 0x41e5
movq 0x3e43(%rip), %rdi      # 0x7fd8
leaq 0xfcb(%rip), %rsi       # 0x5167
movl $0x20, %edx
callq 0x2300
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x3e24(%rip), %rdi      # 0x7fd8
callq 0x2300
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x22b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x21b0
xorl %ebx, %ebx
leaq -0x238(%rbp), %rdi
callq 0x2100
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x420e
jmp 0x420e
jmp 0x420e
jmp 0x420e
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/Ship.cpp
// Function: Ship::~Ship()
Ship::~Ship()
{
    delete[] ship;
    delete[] thruster;
    delete[] colPoints;
    delete[] coefArr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3b32(%rip), %rax      # 0x7d68
movq %rax, (%rdi)
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x4247
callq 0x2310
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x4255
callq 0x2310
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x4263
callq 0x2310
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x4271
callq 0x2310
addq $0x40, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4aae
nop
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/Ship.cpp
// Function: Ship::trace()
void Ship::trace()
{
    cosA = cos(angle);
    sinA = sin(angle);

    int i = 0;
    for (; i < 5; i++) {
        ship[i] = baseFormula(coefArr[i][0], coefArr[i][1], coefArr[i][2], coefArr[i][3]);
    }
    i = 5;
    for (int j = 0; j < 3; j++) {
        thruster[j] = baseFormula(coefArr[i][0], coefArr[i][1], coefArr[i][2], coefArr[i][3]);
        i++;
    }
    for (int j = 0; j < 2; j++) {
        colPoints[j].x = ship[j].x;
        colPoints[j].y = ship[j].y;
        colPoints[j].w = 2;
        colPoints[j].h = 2;
    }
    colPoints[2].x = ship[3].x;
    colPoints[2].y = ship[3].y;
    colPoints[2].w = 2;
    colPoints[2].h = 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss 0x18(%rdi), %xmm0
callq 0x2200
movss %xmm0, 0x24(%rbx)
movss 0x18(%rbx), %xmm0
callq 0x2230
movss %xmm0, 0x28(%rbx)
xorl %eax, %eax
movq 0x30(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
xorps %xmm0, %xmm0
cvtsi2ssl (%rcx), %xmm0
movss 0x24(%rbx), %xmm1
movss 0x28(%rbx), %xmm2
xorps %xmm3, %xmm3
cvtsi2ssl 0x4(%rcx), %xmm3
mulss %xmm2, %xmm3
mulss %xmm1, %xmm0
xorps %xmm4, %xmm4
cvtsi2ssl 0x10(%rbx), %xmm4
subss %xmm3, %xmm0
addss %xmm0, %xmm4
cvttss2si %xmm4, %edx
xorps %xmm0, %xmm0
cvtsi2ssl 0x8(%rcx), %xmm0
xorps %xmm3, %xmm3
cvtsi2ssl 0xc(%rcx), %xmm3
mulss %xmm1, %xmm3
mulss %xmm2, %xmm0
addss %xmm3, %xmm0
xorps %xmm1, %xmm1
cvtsi2ssl 0x14(%rbx), %xmm1
addss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
shlq $0x20, %rcx
orq %rcx, %rdx
movq 0x70(%rbx), %rcx
movq %rdx, (%rcx,%rax,8)
incq %rax
cmpq $0x5, %rax
jne 0x42ad
xorl %eax, %eax
movq 0x30(%rbx), %rcx
movq 0x28(%rcx,%rax,8), %rcx
xorps %xmm0, %xmm0
cvtsi2ssl (%rcx), %xmm0
movss 0x24(%rbx), %xmm1
movss 0x28(%rbx), %xmm2
xorps %xmm3, %xmm3
cvtsi2ssl 0x4(%rcx), %xmm3
mulss %xmm2, %xmm3
mulss %xmm1, %xmm0
xorps %xmm4, %xmm4
cvtsi2ssl 0x10(%rbx), %xmm4
subss %xmm3, %xmm0
addss %xmm0, %xmm4
cvttss2si %xmm4, %edx
xorps %xmm0, %xmm0
cvtsi2ssl 0x8(%rcx), %xmm0
xorps %xmm3, %xmm3
cvtsi2ssl 0xc(%rcx), %xmm3
mulss %xmm1, %xmm3
mulss %xmm2, %xmm0
addss %xmm3, %xmm0
xorps %xmm1, %xmm1
cvtsi2ssl 0x14(%rbx), %xmm1
addss %xmm0, %xmm1
cvttss2si %xmm1, %ecx
shlq $0x20, %rcx
orq %rcx, %rdx
movq 0x78(%rbx), %rcx
movq %rdx, (%rcx,%rax,8)
incq %rax
cmpq $0x3, %rax
jne 0x4334
movq 0x38(%rbx), %rcx
movq 0x70(%rbx), %rdx
xorl %esi, %esi
movabsq $0x200000002, %rax      # imm = 0x200000002
movl (%rdx,%rsi), %edi
movl %edi, (%rcx,%rsi,2)
movl 0x4(%rdx,%rsi), %edi
movl %edi, 0x4(%rcx,%rsi,2)
movq %rax, 0x8(%rcx,%rsi,2)
addq $0x8, %rsi
cmpq $0x8, %rsi
je 0x43ce
movq 0x38(%rbx), %rcx
movq 0x70(%rbx), %rdx
movl 0x18(%rdx), %esi
movl %esi, 0x20(%rcx)
movl 0x1c(%rdx), %edx
movl %edx, 0x24(%rcx)
movq %rax, 0x28(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/Ship.cpp
// Function: Ship::interpolate(float const&, float const&)
void Ship::interpolate(const float& dT, const float& i)
{
    position.x = prevPosition.x - (velocity[0] * dT) * i;
    position.y = prevPosition.y - (velocity[1] * dT) * i;
    if (alive) {
        this->trace();
    } else {
        this->deadAnimation();
    }

    for (auto j = bullets.begin(); j != bullets.end(); j++)
    {
        j->second.interpolate(dT, i);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cvtsi2ssl 0x8(%rdi), %xmm0
movss (%rsi), %xmm1
movss (%rdx), %xmm2
movss 0x1c(%rdi), %xmm3
mulss %xmm1, %xmm3
mulss %xmm2, %xmm3
subss %xmm3, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x10(%rdi)
xorps %xmm0, %xmm0
cvtsi2ssl 0xc(%rdi), %xmm0
mulss 0x20(%rdi), %xmm1
mulss %xmm2, %xmm1
subss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x14(%rdi)
cmpb $0x1, 0x88(%rdi)
jne 0x4670
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
jmp 0x4678
movq $0x0, 0x1c(%r15)
movq 0x58(%r15), %r12
addq $0x48, %r15
cmpq %r15, %r12
je 0x46a5
leaq 0x40(%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2d34
movq %r12, %rdi
callq 0x21c0
movq %rax, %r12
cmpq %r15, %rax
jne 0x4685
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tkaczenko[P]asteroids-clone/src/Ship.cpp
// Function: Ship::draw(SDL_Renderer*)
void Ship::draw(SDL_Renderer* r)
{
    SDL_SetRenderDrawColor(r, 255, 255, 255, 255);

    if (alive)
    {
        if (thrust) {
            SDL_RenderDrawLines(r, ship, 5);
            SDL_SetRenderDrawColor(r, 255, 255, 0, 0);
            SDL_RenderDrawLines(r, thruster, 3);
        } else {
            SDL_RenderDrawLines(r, ship, 5);
        }
        for (auto i = bullets.begin(); i != bullets.end(); i++) {
            i->second.draw(r);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0xff, %esi
movl $0xff, %edx
movl $0xff, %ecx
movl $0xff, %r8d
callq 0x2320
cmpb $0x1, 0x88(%r14)
jne 0x4762
movb 0x89(%r14), %r15b
movq 0x70(%r14), %rsi
movq %rbx, %rdi
movl $0x5, %edx
callq 0x21a0
cmpb $0x1, %r15b
jne 0x4739
movq %rbx, %rdi
movl $0xff, %esi
movl $0xff, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2320
movq 0x78(%r14), %rsi
movq %rbx, %rdi
movl $0x3, %edx
callq 0x21a0
movq 0x58(%r14), %r15
addq $0x48, %r14
cmpq %r14, %r15
je 0x4762
leaq 0x40(%r15), %rdi
movq %rbx, %rsi
callq 0x2d7c
movq %r15, %rdi
callq 0x21c0
movq %rax, %r15
cmpq %r14, %rax
jne 0x4746
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/shuhaosun[P]Splitter-Windowed-CountMin/./Splitter.h
// Function: Splitter::Splitter(int, int)
Splitter(int _w, int _d)
	{
		mem_acc = 0;
		counter_index_size = 20;
		w = _w;
		d = _d;
		
		for(int i = 0; i < d; i++)	
		{
			counter[i] = new double[w];
			memset(counter[i], 0, sizeof(double) * w);
		}

		MAX_CNT = (1 << COUNTER_SIZE) - 1;

		for(int i = 0; i < d; i++)
		{
			bobhash32[i] = new BOBHash32(i + 1000);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movq $0x0, 0x7a13a8(%rdi)
movl $0x14, 0x19c(%rdi)
movl %esi, 0x190(%rdi)
movl %edx, 0x194(%rdi)
movl %edx, %r12d
testl %edx, %edx
jle 0x1b10
movslq %esi, %r14
shlq $0x3, %r14
testl %esi, %esi
movq $-0x1, %r15
cmovnsq %r14, %r15
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x1030
movq %rax, 0xf0(%rbx,%r13,8)
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x10a0
incq %r13
cmpq %r13, %r12
jne 0x1aeb
movl $0xffff, 0x198(%rbx)    # imm = 0xFFFF
testl %ebp, %ebp
jle 0x1b40
xorl %r14d, %r14d
movl $0x4, %edi
callq 0x1120
leal 0x3e8(%r14), %ecx
movl %ecx, (%rax)
movq %rax, (%rbx,%r14,8)
incq %r14
cmpq %r14, %r12
jne 0x1b21
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/shuhaosun[P]Splitter-Windowed-CountMin/./Splitter.h
// Function: Splitter::Query(char const*, int)
double Query(const char *str, int t)
	{
		double min_value = MAX_CNT;
		double temp;
		for(int i = 0; i < d; i++)
		{
			index[i] = (bobhash32[i]->run(str, strlen(str))) % w;
			int ij = w*i + index[i];
			Expire(head[ij], t, i, index[i]);

			temp = counter[i][index[i]];
			min_value = temp < min_value ? temp : min_value;
		}
		return min_value;
	}

// Assembly:
cvtsi2sdl 0x198(%rdi), %xmm1
cmpl $0x0, 0x194(%rdi)
jle 0x1e30
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movsd %xmm1, 0x8(%rsp)
movq (%r15,%r12,8), %r13
movq %r14, %rdi
callq 0x1090
movq %r13, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x13dc
xorl %edx, %edx
divl 0x190(%r15)
movl %edx, %r8d
movl %edx, 0xa0(%r15,%r12,4)
movl 0x190(%r15), %eax
imull %r12d, %eax
addl %edx, %eax
cltq
movq 0x1a8(%r15,%rax,8), %rsi
movq %r15, %rdi
movl %ebx, %edx
movl %r12d, %ecx
callq 0x1ed6
movq 0xf0(%r15,%r12,8), %rax
movslq 0xa0(%r15,%r12,4), %rcx
movsd (%rax,%rcx,8), %xmm0
minsd 0x8(%rsp), %xmm0
incq %r12
movslq 0x194(%r15), %rax
movapd %xmm0, %xmm1
cmpq %rax, %r12
jl 0x1d99
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movapd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/shuhaosun[P]Splitter-Windowed-CountMin/./Splitter.h
// Function: Splitter::Expire(Node*, int, int, int)
void Expire(DLNode *head, int t, int i, int j)
	{
		DLNode *p, *q;
		double ratio;
		double scale;

		p = head->next;

		while(p != head && ((p->init < t - WINDOW_SIZE) || (p->init == t - WINDOW_SIZE)))
		{
			if (p->last > t - WINDOW_SIZE)//the second node is totally in the window
			{
				ratio = (t - WINDOW_SIZE) - p->init + 1;
				scale = p->count / (p->last - p->init + 1);
				counter[i][j] = counter[i][j] - ratio*scale;

				p->count = p->count - ratio*scale;
				p->init = p->init + ratio;
				p = p->next;
			}
			else
			{
				counter[i][j] = counter[i][j] - p->count;

				//delete p node
				q = p;
				p = p->next;
			    q->prior->next = q->next;
				q->next->prior = q->prior;
				free(q);
				if (p == head)
				{
					counter[i][j] = 0;
				}
				memoryusage = memoryusage - 2*12 - 16;
			}
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x18(%rsi), %rdi
cmpq %rsi, %rdi
je 0x1fed
movq %rsi, %rbx
cvtsi2sd %edx, %xmm4
addsd 0x1156(%rip), %xmm4     # 0x3058
movslq %ecx, %r15
movslq %r8d, %r12
movsd %xmm4, 0x8(%rsp)
movsd (%rdi), %xmm0
ucomisd %xmm0, %xmm4
jb 0x1fed
movsd 0x8(%rdi), %xmm1
ucomisd %xmm4, %xmm1
jbe 0x1f8c
movapd %xmm4, %xmm2
subsd %xmm0, %xmm2
movsd 0x1129(%rip), %xmm5     # 0x3060
addsd %xmm5, %xmm2
movsd 0x10(%rdi), %xmm3
subsd %xmm0, %xmm1
addsd %xmm5, %xmm1
divsd %xmm1, %xmm3
movq 0xf0(%r14,%r15,8), %rax
movapd %xmm2, %xmm0
xorpd 0x1150(%rip), %xmm0     # 0x30b0
mulsd %xmm3, %xmm0
movsd (%rax,%r12,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rax,%r12,8)
addsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x10(%rdi)
addsd (%rdi), %xmm2
movsd %xmm2, (%rdi)
movq 0x18(%rdi), %r13
jmp 0x1fe1
movq 0xf0(%r14,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
subsd 0x10(%rdi), %xmm0
movsd %xmm0, (%rax,%r12,8)
movq 0x18(%rdi), %r13
movq 0x20(%rdi), %rax
movq %r13, 0x18(%rax)
movq 0x18(%rdi), %rcx
movq %rax, 0x20(%rcx)
callq 0x1150
cmpq %rbx, %r13
jne 0x1fd3
movq 0xf0(%r14,%r15,8), %rax
movq $0x0, (%rax,%r12,8)
addl $-0x28, 0x7a13ac(%r14)
movsd 0x8(%rsp), %xmm4
movq %r13, %rdi
cmpq %rbx, %r13
jne 0x1f0e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/shuhaosun[P]Splitter-Windowed-CountMin/./Splitter.h
// Function: Splitter::Error(Node*, Node*)
double Error(DLNode *p, DLNode *l)
	{
		double error;
		double Fprev = p->count / (l->init - p->init);
		double Fnow = l->count / (l->last - l->init + 1);
		if (Fprev > Fnow) 
			error = Fprev / Fnow;
		else 
			error = Fnow / Fprev;

		if (error == 0)
		{
			printf("error = : %f\n", error);
		}
		return error;
	}

// Assembly:
movsd (%rdx), %xmm0
movsd 0x8(%rdx), %xmm1
subsd %xmm0, %xmm1
subsd (%rsi), %xmm0
addsd 0x104b(%rip), %xmm1     # 0x3060
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movsd 0x10(%rsi), %xmm1
movhpd 0x10(%rdx), %xmm1       # xmm1 = xmm1[0],mem[0]
divpd %xmm0, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
movapd %xmm1, %xmm3
divsd %xmm0, %xmm3
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
cmpltsd %xmm1, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm2, %xmm0
orpd %xmm3, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x207c
jp 0x207c
subq $0x18, %rsp
leaq 0x1126(%rip), %rdi      # 0x318d
movb $0x1, %al
movapd %xmm0, (%rsp)
callq 0x1040
movapd (%rsp), %xmm0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char>::operator*(unsigned long) const
basic_string<_Elme> basic_string<_Elme>::operator*(size_t i) const
{
  if (i <= 0)
    return "";
  basic_string<_Elme> str(*this);
  str.reserve(str.size() * i);
  for (; --i;) {
    str += *this;
  }
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
testq %rdx, %rdx
je 0x5a14
movq %rdx, %r14
movq %rsi, %r15
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x688c
movq 0x8(%rbx), %rsi
imulq %r14, %rsi
movq %rbx, %rdi
callq 0x4470
decq %r14
je 0x5a26
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x40c0
jmp 0x59fe
leaq 0x1685c(%rip), %rdx     # 0x1c277
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6436
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5a34
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x5a4b
movq (%r12), %rsi
incq %rsi
callq 0x42d0
movq %r14, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O1/ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char>::slice(py::null_allow::null_allow<int>, py::null_allow::null_allow<int>, py::null_allow::null_allow<int>) const
basic_string<_Elme> basic_string<_Elme>::slice(optional_int start,
                                               optional_int end,
                                               optional_int step) const
{
  if (step == 0)
    return "";
  if (!step.has_value() || step == 1)
    return this->slice(start, end);

  int start_i, step_i, len_i;
  basic_string<_Elme> str = "";
  std::tie(start_i, std::ignore, step_i, len_i)
    = util::adjust_index<int>(start, end, step, this->size());

  for (int i = 0; i < len_i; i += 1) {
    str.push_back(this->at(start_i));
    start_i += step_i;
  }
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rdi, %rbx
testl %r15d, %r15d
je 0x5afb
movq %rdx, %r13
movq %rsi, %r14
movq %r15, %rax
shrq $0x20, %rax
andl $0x1, %eax
cmpl $0x1, %r15d
setne %dl
testb %al, %dl
je 0x5b19
movq %rcx, -0x38(%rbp)
leaq 0x10(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rbx)
leaq 0x167ce(%rip), %rdx     # 0x1c277
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6436
movl 0x8(%r14), %ecx
xorl %r12d, %r12d
movl %ecx, %eax
movl $0x0, %edx
movl %ecx, %esi
testl %r15d, %r15d
jns 0x5ada
leal -0x1(%rcx), %r12d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %r12d, %esi
movabsq $0x100000000, %r8       # imm = 0x100000000
testq %r8, %r13
movq -0x38(%rbp), %rdi
je 0x5b36
testl %r13d, %r13d
js 0x5b29
cmpl %r13d, %esi
cmovll %esi, %r13d
jmp 0x5b33
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1676e(%rip), %rdx     # 0x1c277
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6436
jmp 0x5ba8
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1244e
jmp 0x5ba8
addl %ecx, %r13d
cmpl %edx, %r13d
cmovlel %edx, %r13d
movl %r13d, %r12d
testq %r8, %rdi
je 0x5b51
testl %edi, %edi
js 0x5b48
cmpl %edi, %esi
cmovll %esi, %edi
movl %edi, %eax
jmp 0x5b51
addl %edi, %ecx
cmpl %edx, %ecx
cmovlel %edx, %ecx
movl %ecx, %eax
testl %r15d, %r15d
js 0x5b68
cmpl %eax, %r12d
jge 0x5b82
movl %r12d, %ecx
notl %ecx
addl %ecx, %eax
cltd
idivl %r15d
jmp 0x5b7a
cmpl %r12d, %eax
jge 0x5b82
notl %eax
addl %r12d, %eax
movl %r15d, %ecx
negl %ecx
cltd
idivl %ecx
movl %eax, %r13d
incl %r13d
jmp 0x5b85
xorl %r13d, %r13d
testl %r13d, %r13d
jle 0x5ba8
movq %r14, %rdi
movl %r12d, %esi
callq 0x124be
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x4280
addl %r15d, %r12d
decl %r13d
jne 0x5b8a
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x5bd5
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x42d0
movq %r14, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O1/ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char>::operator[](std::initializer_list<py::null_allow::null_allow<int>>)
basic_string<_Elme>
basic_string<_Elme>::operator[](std::initializer_list<optional_int> slice)
{
  basic_string<_Elme> str;
  auto in = slice.begin();
  optional_int index1 = *in++;
  optional_int index2 = *in++;
  optional_int index3 = *in;

  switch (slice.size()) {
  case 0:
    return *this;
  case 1:
    return this->slice(index1);
  case 2:
    return this->slice(index1, index2);
  default: // case 3:
    return this->slice(index1, index2, index3);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r8
movq %rdx, %rax
movq %rdi, %rbx
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq (%rdx), %rdx
movq 0x8(%rax), %rcx
cmpq $0x2, %r8
je 0x5c46
cmpq $0x1, %r8
je 0x5c3c
testq %r8, %r8
jne 0x5c50
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x688c
jmp 0x5c5c
movq %rbx, %rdi
callq 0x12518
jmp 0x5c5c
movq %rbx, %rdi
callq 0x1244e
jmp 0x5c5c
movq 0x10(%rax), %r8
movq %rbx, %rdi
callq 0x5a54
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x5c71
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x5c95
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O1/ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char> py::basic_string<char>::format<int, char const*, int>(int, char const*, int)
basic_string<_Elme> basic_string<_Elme>::format(Args... args)
{
  basic_string<_Elme> str(*this);
  static std::regex match("\\{(![^:])?(:(.+?)?)?\\}");
  if (std::regex_search(str, match)) {
    return this->_format_automatic(str, std::move(args)...);
  }
  return this->_format<0>(str, std::move(args)...);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, -0x2c(%rbp)
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x688c
movb 0x1fa88(%rip), %al      # 0x25768
testb %al, %al
je 0x5d8c
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x1fa40(%rip), %rcx     # 0x25748
xorl %r8d, %r8d
callq 0x12f2c
movl %eax, %r14d
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x5d28
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x42d0
testb %r14b, %r14b
je 0x5d48
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %ecx
movq %r15, %r8
movl -0x2c(%rbp), %r9d
callq 0x12572
jmp 0x5d61
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %ecx
movq %r15, %r8
movl -0x2c(%rbp), %r9d
callq 0x128e0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5d7a
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f9d5(%rip), %rdi     # 0x25768
callq 0x4530
testl %eax, %eax
je 0x5ce8
leaq 0x1f9a1(%rip), %rdi     # 0x25748
leaq 0x16d7b(%rip), %rsi     # 0x1cb29
movl $0x10, %edx
callq 0x5926
leaq -0x42d(%rip), %rdi      # 0x5992
leaq 0x1f982(%rip), %rsi     # 0x25748
leaq 0x1f4fb(%rip), %rdx     # 0x252c8
callq 0x4290
leaq 0x1f98f(%rip), %rdi     # 0x25768
callq 0x41f0
jmp 0x5ce8
movq %rax, %rbx
leaq 0x1f97b(%rip), %rdi     # 0x25768
callq 0x41e0
jmp 0x5e11
movq %rax, %rbx
jmp 0x5e11
movq %rax, %rbx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x5e11
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x42d0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5e2a
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O1/ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char>::pyreplace(py::basic_string<char>, py::basic_string<char>, unsigned long) const
basic_string<_Elme> basic_string<_Elme>::pyreplace(basic_string<_Elme> old,
                                                   basic_string<_Elme> _new,
                                                   size_t count) const
{
  size_t cursor = 0;
  basic_string<_Elme> s(*this);
  size_t oldlen = old.size(), newlen = _new.size();
  cursor = s.find(old, cursor);
  while (cursor != std::basic_string<_Elme>::npos && cursor <= s.size()
         && count > 0) {
    s.replace(cursor, oldlen, _new);
    cursor += newlen;
    if (oldlen != 0) {
      cursor = s.find(old, cursor);
    } else {
      ++cursor;
    }
    --count;
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x688c
movq (%r12), %rsi
movq %r12, -0x38(%rbp)
movq 0x8(%r12), %r13
movq 0x8(%r15), %rax
movq %rax, -0x40(%rbp)
movq %rbx, %rdi
xorl %edx, %edx
movq %r13, %rcx
callq 0x4500
cmpq $-0x1, %rax
je 0x6074
movq %rax, %r12
addq $-0x1, %r14
setb %al
cmpq 0x8(%rbx), %r12
ja 0x6074
testb %al, %al
je 0x6074
movq (%r15), %rcx
movq 0x8(%r15), %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4330
addq -0x40(%rbp), %r12
testq %r13, %r13
je 0x606b
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rcx
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4500
movq %rax, %r12
jmp 0x606e
incq %r12
cmpq $-0x1, %r12
jne 0x6021
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x60a1
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x42d0
movq %r14, %rdi
callq 0x4510
nop