LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rbx, %rdi
callq 0x2cf8
movb $0x1, 0xd8(%r14)
movaps 0x29d3(%rip), %xmm0     # 0x5010
movups %xmm0, 0x118(%r14)
movl $0x5, 0x128(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x12c(%r14)
andl $0x0, 0x13c(%r14)
movl $0xf231, %edi           # imm = 0xF231
callq 0x2270
testl %eax, %eax
je 0x2699
movq 0x5960(%rip), %rdi      # 0x7fd8
leaq 0x29b5(%rip), %rsi      # 0x5034
callq 0x22d0
movq %rax, %r14
callq 0x2200
movq %r14, %rdi
movq %rax, %rsi
callq 0x22d0
jmp 0x2707
pushq $0x8
popq %rdi
callq 0x22e0
movq %rax, %r15
leaq 0x29a1(%rip), %rsi      # 0x504c
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x2140
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x2ab4
movq %r15, (%r14)
leaq -0x40(%rbp), %rdi
callq 0x2170
pushq $0x8
popq %rdi
callq 0x22e0
movq %rax, %r15
movq (%r14), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0x2aec
movq %r15, 0x8(%r14)
callq 0x22f0
movl %eax, 0x130(%r14)
xorl %edi, %edi
callq 0x2290
movl %eax, %edi
callq 0x22c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2722
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x2170
jmp 0x2725
movq %rax, %r14
movq %r15, %rdi
callq 0x22b0
jmp 0x2732
movq %rax, %r14
movq %rbx, %rdi
callq 0x2fce
movq %r14, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/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:
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
movl $0x3a98, %r13d          # imm = 0x3A98
cmpb $0x1, 0xd8(%rbx)
jne 0x2902
callq 0x22f0
movl 0x138(%rbx), %ecx
movl $0x3e8, %edx            # imm = 0x3E8
addl %edx, %ecx
cmpl %ecx, %eax
jbe 0x27f4
callq 0x22f0
movl %eax, 0x138(%rbx)
callq 0x22f0
movl 0x13c(%rbx), %ecx
addl %r13d, %ecx
cmpl %ecx, %eax
jbe 0x283f
movl $0x259, -0x38(%rbp)     # imm = 0x259
andl $0x0, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
andl $0x0, -0x2c(%rbp)
movq %r14, %rdi
leaq -0x38(%rbp), %rsi
leaq -0x34(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x2c(%rbp), %r8
callq 0x2d92
callq 0x22f0
movl %eax, 0x13c(%rbx)
movq %rbx, %rdi
callq 0x2914
andl $0x0, 0x12c(%rbx)
callq 0x22f0
subl 0x134(%rbx), %eax
cvtsi2ss %rax, %xmm0
divss 0x27ca(%rip), %xmm0     # 0x5030
movss %xmm0, 0x118(%rbx)
callq 0x22f0
cmpl 0x130(%rbx), %eax
jbe 0x28b3
movl 0x12c(%rbx), %eax
cmpl 0x128(%rbx), %eax
jge 0x28b3
movq %r14, %rdi
movq %r15, %rsi
callq 0x326a
movl 0x124(%rbx), %eax
addl %eax, 0x130(%rbx)
callq 0x22f0
movl %eax, 0x134(%rbx)
incl 0x12c(%rbx)
jmp 0x286e
callq 0x22f0
movl 0x124(%rbx), %ecx
addl %ecx, %eax
subl 0x130(%rbx), %eax
cvtsi2ss %rax, %xmm0
cvtsi2ss %ecx, %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x11c(%rbx)
movq %r14, %rdi
callq 0x30a4
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x32b8
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x330e
jmp 0x27c6
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tkaczenko[P]asteroids-clone/src/../include/../include/Window.h
// Function: Window::Window(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Window(const std::string& title) {
        hwWin = SDL_CreateWindow(title.c_str(),
                        SDL_WINDOWPOS_CENTERED,
                        SDL_WINDOWPOS_CENTERED,
                        WINDOW_WIDTH,
                        WINDOW_HEIGHT,
                        SDL_WINDOW_SHOWN);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, (%rdi)
movq (%rsi), %rdi
pushq $0x4
popq %r9
movl $0x2fff0000, %esi       # imm = 0x2FFF0000
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
movl $0x320, %ecx            # imm = 0x320
movl $0x258, %r8d            # imm = 0x258
callq 0x2070
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x18(%rdi)
andq $0x0, 0x24(%rdi)
movq %rsi, %rax
leaq 0x5115(%rip), %r10      # 0x7c88
movq %r10, (%rdi)
andl $0x0, 0x2c(%rdi)
movl (%r9), %r9d
movl %r9d, 0x30(%rdi)
andl $0x0, 0x34(%rdi)
shrq $0x20, %rax
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_O2/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, %eax
movl %eax, 0x10(%rdi)
cvtsi2ssl 0xc(%rdi), %xmm0
mulss 0x20(%rdi), %xmm1
subss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, 0x14(%rdi)
movl $0xfffffce0, %edx       # imm = 0xFFFFFCE0
cmpl $0x320, %eax            # imm = 0x320
jg 0x2c05
testl %eax, %eax
jns 0x2c0a
movl $0x320, %edx            # imm = 0x320
addl %edx, %eax
movl %eax, 0x10(%rdi)
movl $0xfffffda8, %edx       # imm = 0xFFFFFDA8
cmpl $0x258, %ecx            # imm = 0x258
jg 0x2c20
testl %ecx, %ecx
jns 0x2c25
movl $0x258, %edx            # imm = 0x258
addl %edx, %ecx
movl %ecx, 0x14(%rdi)
cmpl $0x25c, 0x38(%rdi)      # imm = 0x25C
jne 0x2c41
movl 0x2c(%rdi), %edx
cmpl $0x1a, %edx
jl 0x2c3c
movb $0x1, 0x3c(%rdi)
jmp 0x2c41
incl %edx
movl %edx, 0x2c(%rdi)
movl %eax, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2ce1
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r8
movq %rsi, %rdi
xorl %esi, %esi
movl $0xff, %edx
xorl %ecx, %ecx
callq 0x2340
movl 0x10(%r14), %esi
movl 0x14(%r14), %edx
movq %rbx, %rdi
callq 0x2280
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0xff, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x2340
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3031
cmpb $0x1, 0x88(%rbx)
jne 0x309d
movl (%rsi), %eax
cmpq $0x3, %rax
ja 0x309d
leaq 0x206d(%rip), %rcx      # 0x508c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, 0x89(%rbx)
jmp 0x309d
movl (%rsi), %eax
cmpq $0x4, %rax
ja 0x309d
leaq 0x2038(%rip), %rcx      # 0x5078
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
andl $0x0, 0x80(%rbx)
jmp 0x309d
movb $0x1, 0x88(%rbx)
jmp 0x309d
movb $0x0, 0x89(%rbx)
jmp 0x309d
movb $0x1, 0x8a(%rbx)
jmp 0x309d
movl $0x2, 0x80(%rbx)
jmp 0x309d
cmpb $0x1, 0x8a(%rbx)
jne 0x309d
movq %rbx, %rdi
callq 0x4264
movb $0x0, 0x8a(%rbx)
jmp 0x309d
movl $0x1, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3f8e
movq 0xa8(%r14), %r15
addq $0x98, %r14
cmpq %r14, %r15
je 0x32ad
leaq 0x40(%r15), %rdi
movq 0x40(%r15), %rax
movq %rbx, %rsi
callq *0x8(%rax)
movq %r15, %rdi
callq 0x21d0
movq %rax, %r15
jmp 0x328d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4110
movq 0xa8(%r15), %r12
addq $0x98, %r15
cmpq %r15, %r12
je 0x3304
leaq 0x40(%r12), %rdi
movq 0x40(%r12), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
movq %r12, %rdi
callq 0x21d0
movq %rax, %r12
jmp 0x32df
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x3422
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x41ba
movq 0xa8(%r14), %r15
addq $0x98, %r14
cmpq %r14, %r15
je 0x335f
leaq 0x40(%r15), %rdi
movq (%rbx), %rsi
movq 0x40(%r15), %rax
callq *0x18(%rax)
movq %r15, %rdi
callq 0x21d0
movq %rax, %r15
jmp 0x333f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x344e
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x18(%rdi)
andq $0x0, 0x24(%rdi)
leaq 0x44a1(%rip), %rcx      # 0x7d28
movq %rcx, (%rdi)
andl $0x0, 0x2c(%rdi)
shrq $0x20, %rax
movl (%r9), %ecx
movl %ecx, 0x30(%rdi)
movl (%r8), %ecx
movl %ecx, 0x34(%rdi)
andl $0x0, 0x98(%rdi)
movl %esi, 0x10(%rdi)
movl %eax, 0x14(%rdi)
movl %esi, 0x8(%rdi)
movl %eax, 0xc(%rdi)
callq 0x2110
movl $0x13a, %ecx            # imm = 0x13A
cltd
idivl %ecx
movl %edx, %eax
movw $0x64, %cx
cwtd
idivw %cx
cwtl
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x18(%rbx)
xorl %eax, %eax
testb $0x1, 0x30(%rbx)
sete %al
leaq 0x17c5(%rip), %rcx      # 0x50a8
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
movl $0xff, %r12d
cltd
idivl %r12d
movl %edx, %r14d
callq 0x2110
cltd
idivl %r12d
movl %edx, %r15d
callq 0x2110
cltd
idivl %r12d
movb %r14b, 0x38(%rbx)
movb %r15b, 0x39(%rbx)
movb %dl, 0x3a(%rbx)
movb $0x0, 0x3b(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x394a
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x64
popq %r15
cmpq $0xa, %r14
je 0x3995
callq 0x2110
cltd
idivl %r15d
cvtsi2sd %edx, %xmm0
divsd 0x1737(%rip), %xmm0     # 0x50b0
mulsd 0x1737(%rip), %xmm0     # 0x50b8
addsd 0x1737(%rip), %xmm0     # 0x50c0
movsd %xmm0, 0x40(%rbx,%r14,8)
incq %r14
jmp 0x395e
movsd 0x40(%rbx), %xmm0
movsd %xmm0, 0x90(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
cvtsi2sd %esi, %xmm0
movsd %xmm0, -0x20(%rbp)
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x16, %r14
je 0x3a79
cvtsi2sd %r14d, %xmm0
mulsd 0x16b6(%rip), %xmm0     # 0x50c8
divsd 0x16b6(%rip), %xmm0     # 0x50d0
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 0x20d0
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
jmp 0x39ff
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %eax
movl %eax, 0x10(%rdi)
cvtsi2ssl 0xc(%rdi), %xmm0
mulss 0x20(%rdi), %xmm1
subss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, 0x14(%rdi)
movl $0xfffffce0, %edx       # imm = 0xFFFFFCE0
cmpl $0x320, %eax            # imm = 0x320
jg 0x3acf
testl %eax, %eax
jns 0x3ad4
movl $0x320, %edx            # imm = 0x320
addl %edx, %eax
movl %eax, 0x10(%rdi)
movl $0xfffffda8, %edx       # imm = 0xFFFFFDA8
cmpl $0x258, %ecx            # imm = 0x258
jg 0x3afd
testl %ecx, %ecx
js 0x3af8
je 0x3aeb
testl %eax, %eax
jne 0x3b02
addl $-0x14, %eax
movl %eax, 0x10(%rdi)
movl $0xffffffec, %edx       # imm = 0xFFFFFFEC
jmp 0x3afd
movl $0x258, %edx            # imm = 0x258
addl %edx, %ecx
movl %ecx, 0x14(%rdi)
movss 0x98(%rdi), %xmm0
addss 0x18(%rdi), %xmm0
movss %xmm0, 0x18(%rdi)
movl %eax, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
andl $0x0, 0x18(%rdi)
andq $0x0, 0x24(%rdi)
leaq 0x419a(%rip), %rax      # 0x7d70
movq %rax, (%rdi)
andl $0x0, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
leaq 0x48(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movq %rax, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movups %xmm0, 0x68(%rdi)
movups %xmm0, 0x78(%rdi)
movw $0x1, 0x88(%rdi)
movb $0x1, 0x8a(%rdi)
andl $0x0, 0x8c(%rdi)
movaps 0x14d5(%rip), %xmm0     # 0x50f0
movups %xmm0, 0x8(%rdi)
pushq $0x28
popq %rdi
callq 0x2040
movq %rax, 0x70(%rbx)
pushq $0x18
popq %rdi
callq 0x2040
movq %rax, 0x78(%rbx)
pushq $0x30
popq %rdi
callq 0x2040
movq %rax, 0x38(%rbx)
leaq 0x14d6(%rip), %rsi      # 0x5120
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x2140
leaq -0x38(%rbp), %rsi
callq 0x3caa
movq %rax, 0x30(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x2170
andq $0x0, 0x1c(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x2170
jmp 0x3c96
jmp 0x3c93
movq %rax, %r14
addq $0x40, %rbx
movq %rbx, %rdi
callq 0x447e
movq %r14, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x240(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x2390
leaq -0x1c8(%rbp), %rdi
callq 0x20e0
testb %al, %al
je 0x3d86
leaq -0x240(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x21b0
leaq -0x240(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x21b0
movslq -0x30(%rbp), %r15
leaq (,%r15,8), %rdi
testq %r15, %r15
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
callq 0x2040
movq %rax, -0x38(%rbp)
xorl %r13d, %r13d
leaq -0x240(%rbp), %r14
movslq %r15d, %rax
cmpq %rax, %r13
jge 0x3db0
movslq -0x2c(%rbp), %r12
leaq (,%r12,4), %rdi
testq %r12, %r12
pushq $-0x1
popq %rax
cmovsq %rax, %rdi
callq 0x2040
movq %rax, %r15
movq -0x38(%rbp), %rax
movq %r15, (%rax,%r13,8)
xorl %ebx, %ebx
movslq %r12d, %rax
cmpq %rax, %rbx
jge 0x3d7d
movq %r14, %rdi
movq %r15, %rsi
callq 0x21b0
incq %rbx
movl -0x2c(%rbp), %r12d
addq $0x4, %r15
jmp 0x3d5d
incq %r13
movl -0x30(%rbp), %r15d
jmp 0x3d2d
movq 0x424b(%rip), %rdi      # 0x7fd8
leaq 0x13a3(%rip), %rsi      # 0x5137
callq 0x22d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2260
movq %rax, %rdi
callq 0x2180
xorl %ebx, %ebx
jmp 0x3dc0
leaq -0x240(%rbp), %rdi
callq 0x20c0
movq -0x38(%rbp), %rbx
leaq -0x240(%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 0x3de9
jmp 0x3de9
jmp 0x3de9
jmp 0x3de9
movq %rax, %rbx
leaq -0x240(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3f60(%rip), %rax      # 0x7d70
movq %rax, (%rdi)
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x3e21
callq 0x2310
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x3e2f
callq 0x2310
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x3e3d
callq 0x2310
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x3e4b
callq 0x2310
addq $0x40, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x447e
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
movss 0x18(%rdi), %xmm0
callq 0x21f0
movss %xmm0, 0x24(%rbx)
movss 0x18(%rbx), %xmm0
callq 0x2240
movss %xmm0, 0x28(%rbx)
xorl %r14d, %r14d
cmpq $0x5, %r14
je 0x3eb8
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rsi
leaq 0x4(%rsi), %rdx
leaq 0x8(%rsi), %rcx
leaq 0xc(%rsi), %r8
movq %rbx, %rdi
callq 0x3f34
movq 0x70(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
jmp 0x3e89
xorl %r14d, %r14d
cmpq $0x3, %r14
je 0x3eeb
movq 0x30(%rbx), %rax
movq 0x28(%rax,%r14,8), %rsi
leaq 0x4(%rsi), %rdx
leaq 0x8(%rsi), %rcx
leaq 0xc(%rsi), %r8
movq %rbx, %rdi
callq 0x3f34
movq 0x78(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
jmp 0x3ebb
movq 0x38(%rbx), %rax
movq 0x70(%rbx), %rcx
xorl %esi, %esi
movabsq $0x200000002, %rdx      # imm = 0x200000002
cmpq $0x10, %rsi
je 0x3f1e
movl (%rcx,%rsi), %edi
movl %edi, (%rax,%rsi,2)
movl 0x4(%rcx,%rsi), %edi
movl %edi, 0x4(%rax,%rsi,2)
movq %rdx, 0x8(%rax,%rsi,2)
addq $0x8, %rsi
jmp 0x3eff
movl 0x18(%rcx), %esi
movl %esi, 0x20(%rax)
movl 0x1c(%rcx), %ecx
movl %ecx, 0x24(%rax)
movq %rdx, 0x28(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
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 0x4175
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
jmp 0x417a
andq $0x0, 0x1c(%r15)
movq 0x58(%r15), %r12
addq $0x48, %r15
cmpq %r15, %r12
je 0x41a4
leaq 0x40(%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2c4a
movq %r12, %rdi
callq 0x21d0
movq %rax, %r12
jmp 0x4182
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2340
cmpb $0x1, 0x88(%r14)
jne 0x4259
movb 0x89(%r14), %r15b
movq 0x70(%r14), %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x21c0
cmpb $0x1, %r15b
jne 0x4233
movq %rbx, %rdi
movl $0xff, %esi
movl $0xff, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2340
movq 0x78(%r14), %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x21c0
movq 0x58(%r14), %r15
addq $0x48, %r14
cmpq %r14, %r15
je 0x4259
leaq 0x40(%r15), %rdi
movq %rbx, %rsi
callq 0x2c8e
movq %r15, %rdi
callq 0x21d0
movq %rax, %r15
jmp 0x423b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tkaczenko[P]asteroids-clone/src/Ship.cpp
// Function: Ship::fire()
void Ship::fire()
{
    SDL_Point p = baseFormula(coefArr[0][0], coefArr[0][1], coefArr[0][2], coefArr[0][3]);

    float vX = velocity[0] + 500 * cosA;
    float vY = velocity[1] + 500 * sinA;

    std::stringstream ss;
    ss << bulletNum;
    std::string name = "bullet" + ss.str();

    Bullet sp = {p, vX, vY, BULLET, bulletNum};

    bullets.insert(std::pair<std::string, Bullet>(name, sp));
    bulletNum++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq (%rax), %rsi
leaq 0x4(%rsi), %rdx
leaq 0x8(%rsi), %rcx
leaq 0xc(%rsi), %r8
callq 0x3f34
movss 0xe6f(%rip), %xmm0      # 0x5108
movss 0x24(%rbx), %xmm1
mulss %xmm0, %xmm1
addss 0x1c(%rbx), %xmm1
movss %xmm1, -0x28(%rbp)
mulss 0x28(%rbx), %xmm0
movq %rax, %r14
addss 0x20(%rbx), %xmm0
movss %xmm0, -0x24(%rbp)
leaq -0x270(%rbp), %rdi
callq 0x21e0
leaq -0x260(%rbp), %rdi
movl 0x8c(%rbx), %esi
callq 0x23b0
leaq -0x258(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x2380
leaq 0xe3a(%rip), %rsi       # 0x5130
leaq -0x48(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
callq 0x3371
leaq 0x8c(%rbx), %r15
leaq -0xa8(%rbp), %r12
movq %r12, %rdi
callq 0x2170
movl $0x25c, (%r12)          # imm = 0x25C
leaq -0xe8(%rbp), %rdi
leaq -0x28(%rbp), %rdx
leaq -0x24(%rbp), %rcx
leaq -0xa8(%rbp), %r8
movq %r14, %rsi
movq %r15, %r9
callq 0x2b5c
leaq -0xa8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0xe8(%rbp), %rdx
callq 0x4404
addq $0x40, %rbx
leaq -0xa8(%rbp), %rsi
movq %rbx, %rdi
callq 0x44d6
leaq -0xa8(%rbp), %rdi
callq 0x445e
incl (%r15)
leaq -0xe8(%rbp), %rdi
callq 0x2bb4
leaq -0x48(%rbp), %rdi
callq 0x2170
leaq -0x270(%rbp), %rdi
callq 0x2210
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x445e
jmp 0x43c3
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x2bb4
jmp 0x43d4
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
jmp 0x43e4
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x2170
jmp 0x43f0
jmp 0x43ed
movq %rax, %rbx
leaq -0x270(%rbp), %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/app/tDelete.cpp
// Function: u::tDelete::tDelete(u::Vector<u::String>)
tDelete(Vector<String> arg) : Object()
			{
				Object* o = new tDelete();

				Callback cb(o, cb_cast(&tDelete::callMe));

				o->destroy();
				//cb.call();
				trace("Alive? "+String(valid(o)?"Yes":"No"));

				trace();
				programExit();
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
callq 0x405764
leaq 0x1fad31(%rip), %rax    # 0x5ff7c0
movq %rax, (%rbx)
pushq $0x38
popq %rdi
callq 0x409130
movq %rax, %r15
movq %rax, %rdi
callq 0x404f70
leaq 0x52e(%rip), %rdx       # 0x404fda
leaq 0x78(%rsp), %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4052b4
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
movq $0x60a5a0, %rdi         # imm = 0x60A5A0
leaq 0x18f5a5(%rip), %rsi    # 0x594079
callq 0x4720f0
movq %rax, %r14
movq %r15, %rdi
callq 0x406492
leaq 0x18f59b(%rip), %rcx    # 0x594086
leaq 0x18f598(%rip), %rsi    # 0x59408a
testb %al, %al
cmovneq %rcx, %rsi
leaq 0x20(%rsp), %rdi
callq 0x405be4
leaq 0x58(%rsp), %rdx
leaq 0x18f570(%rip), %rsi    # 0x59407e
movq %rsp, %rdi
callq 0x404e12
movq %rsp, %rsi
movq %r14, %rdi
callq 0x484a20
leaq 0x18f565(%rip), %rsi    # 0x59408d
movq %rax, %rdi
callq 0x4720f0
movq %rax, %rdi
callq 0x4719d0
movq %rsp, %rdi
callq 0x481ff0
leaq 0x20(%rsp), %rdi
callq 0x404a14
movq $0x60a5a0, %rdi         # imm = 0x60A5A0
leaq 0x18f521(%rip), %rsi    # 0x594079
callq 0x4720f0
leaq 0x1ae926(%rip), %rsi    # 0x5b348a
movq %rax, %rdi
callq 0x4720f0
leaq 0x18f51a(%rip), %rsi    # 0x59408d
movq %rax, %rdi
callq 0x4720f0
movq %rax, %rdi
callq 0x4719d0
callq 0x404858
leaq 0x78(%rsp), %rdi
callq 0x405820
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x404bc8
jmp 0x404bb6
movq %rax, %r14
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x408160
jmp 0x404be1
movq %rax, %r14
jmp 0x404be1
jmp 0x404bd4
movq %rax, %r14
movq %rsp, %rdi
callq 0x481ff0
leaq 0x20(%rsp), %rdi
callq 0x404a14
jmp 0x404bd7
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0x405820
movq %rbx, %rdi
callq 0x405820
movq %r14, %rdi
callq 0x4b2fa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
andq $0x0, 0x7a13a8(%rdi)
movl $0x14, 0x19c(%rdi)
movl %esi, 0x190(%rdi)
movl %edx, 0x194(%rdi)
movslq %esi, %rax
leaq (,%rax,8), %r15
testl %eax, %eax
pushq $-0x1
popq %r12
cmovnsq %r15, %r12
xorl %r13d, %r13d
testl %edx, %edx
cmovlel %r13d, %ebx
cmpq %r13, %rbx
je 0x1ab5
movq %r12, %rdi
callq 0x1030
movq %rax, 0xf0(%r14,%r13,8)
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x10d0
incq %r13
jmp 0x1a8e
movl $0xffff, 0x198(%r14) # imm = 0xFFFF
xorl %r12d, %r12d
pushq $0x4
popq %r15
cmpq %r12, %rbx
je 0x1ae7
movq %r15, %rdi
callq 0x1130
leal 0x3e8(%r12), %ecx
movl %ecx, (%rax)
movq %rax, (%r14,%r12,8)
incq %r12
jmp 0x1ac7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/shuhaosun[P]Splitter-Windowed-CountMin/./Splitter.h
// Function: Splitter::Insert(char const*, int)
void Insert(const char * str, int t)
	{
		for(int i = 0; i < d; i++)
		{
			index[i] = (bobhash32[i]->run(str, strlen(str))) % w;
			if((int)counter[i][index[i]] != MAX_CNT)
			{
				int ij = w*i + index[i];
				if(counter[i][index[i]] == 0)
				{
					ListInitiate(&head[ij]);
				}
				else if ( (head[ij]->next->init < t - WINDOW_SIZE) || (head[ij]->next->init == t - WINDOW_SIZE))
				{
					Expire(head[ij], t, i, index[i]);
				}

				if (counter[i][index[i]] < 0)
				{
					counter[i][index[i]] = 0;
				}
				counter[i][index[i]]++;
				if (counter[i][index[i]] == 1)
				{
					ListInsert(head[ij], t, t, 1);
				}
				else if (head[ij]->prior->count < tau*WINDOW_SIZE/(double)w) 
				{
					head[ij]->prior->count++;
					head[ij]->prior->last = t;
				}
				else if (head[ij]->prior->prior != head[ij] && (Error(head[ij]->prior->prior, head[ij]->prior) < mu || Error(head[ij]->prior->prior, head[ij]->prior) == mu))
				{
					Merge(head[ij], t);
				}
				else
				{
					ListInsert(head[ij], t, t, 1);
				}
			}
			mem_acc ++;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cvtsi2sd %edx, %xmm0
leaq 0x1a8(%rdi), %rbp
movsd 0x153d(%rip), %xmm1     # 0x3058
movsd %xmm0, 0x10(%rsp)
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
xorl %r12d, %r12d
movslq 0x194(%r15), %rax
cmpq %rax, %r12
jge 0x1c9e
movq (%r15,%r12,8), %r13
movq %r14, %rdi
callq 0x10a0
movq %r13, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x13c8
movsd 0x1501(%rip), %xmm3     # 0x3060
xorl %edx, %edx
divl 0x190(%r15)
movl %edx, 0xa0(%r15,%r12,4)
movq 0xf0(%r15,%r12,8), %rax
movslq %edx, %rcx
movsd (%rax,%rcx,8), %xmm0
cvttsd2si %xmm0, %eax
cmpl %eax, 0x198(%r15)
je 0x1c8f
movl %edx, %r8d
movl 0x190(%r15), %eax
imull %r12d, %eax
addl %edx, %eax
ucomisd 0x14cf(%rip), %xmm0     # 0x3078
movslq %eax, %r13
leaq (%rbp,%r13,8), %rsi
jne 0x1bbf
jp 0x1bbf
movq %r15, %rdi
callq 0x1e16
jmp 0x1bdf
movq (%rsi), %rsi
movq 0x18(%rsi), %rax
movsd 0x8(%rsp), %xmm0
ucomisd (%rax), %xmm0
jb 0x1be7
movq %r15, %rdi
movl %ebx, %edx
movl %r12d, %ecx
callq 0x1e30
movsd 0x1479(%rip), %xmm3     # 0x3060
movq 0xf0(%r15,%r12,8), %rax
movslq 0xa0(%r15,%r12,4), %rcx
xorpd %xmm0, %xmm0
maxsd (%rax,%rcx,8), %xmm0
addsd %xmm3, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x1a8(%r15,%r13,8), %rax
movq 0x20(%rax), %rdx
movsd 0x10(%rdx), %xmm0
cvtsi2sdl 0x190(%r15), %xmm1
movsd 0x143d(%rip), %xmm2     # 0x3068
divsd %xmm1, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x1c4b
addsd %xmm3, %xmm0
movsd %xmm0, 0x10(%rdx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rdx)
jmp 0x1c8f
movq 0x20(%rdx), %rsi
movq %r15, %rdi
callq 0x1f4e
movsd 0x1411(%rip), %xmm1     # 0x3070
ucomisd %xmm0, %xmm1
ja 0x1c7d
movq 0x1a8(%r15,%r13,8), %rax
movq 0x20(%rax), %rdx
movq 0x20(%rdx), %rsi
movq %r15, %rdi
callq 0x1f4e
movq 0x1a8(%r15,%r13,8), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x1fd0
incl 0x7a13a8(%r15)
incq %r12
jmp 0x1b2e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cvtsi2sdl 0x198(%rdi), %xmm0
xorl %r12d, %r12d
movslq 0x194(%r15), %rax
cmpq %rax, %r12
jge 0x1d54
movq (%r15,%r12,8), %r13
movq %r14, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x10a0
movq %r13, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x13c8
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 0x1e30
movq 0xf0(%r15,%r12,8), %rax
movslq 0xa0(%r15,%r12,4), %rcx
movsd (%rax,%rcx,8), %xmm0
minsd 0x8(%rsp), %xmm0
incq %r12
jmp 0x1cce
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rdi
cvtsi2sd %edx, %xmm4
addsd 0x1205(%rip), %xmm4     # 0x3058
movslq %ecx, %r15
movslq %r8d, %r12
movsd %xmm4, 0x8(%rsp)
cmpq %rbx, %rdi
je 0x1f3f
movsd (%rdi), %xmm0
ucomisd %xmm0, %xmm4
jb 0x1f3f
movsd 0x8(%rdi), %xmm1
ucomisd %xmm4, %xmm1
jbe 0x1ee9
movapd %xmm4, %xmm2
subsd %xmm0, %xmm2
movsd 0x11cf(%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 0x11f6(%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), %rdi
jmp 0x1e5f
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 %rax, 0x20(%r13)
callq 0x1150
cmpq %rbx, %r13
jne 0x1f29
movq 0xf0(%r14,%r15,8), %rax
andq $0x0, (%rax,%r12,8)
addl $-0x28, 0x7a13ac(%r14)
movq %r13, %rdi
movsd 0x8(%rsp), %xmm4
jmp 0x1e5f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10f9(%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 0x1fce
jp 0x1fce
subq $0x18, %rsp
leaq 0x11d4(%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_O2/shuhaosun[P]Splitter-Windowed-CountMin/./Splitter.h
// Function: Splitter::Merge(Node*, int)
void Merge(DLNode *head, int t)
	{
		DLNode *p,*l;
		l = head->prior;
		p = l->prior;
		p->count = p->count + l->count;
        p->last = l->last;
        l->count = 1;
        l->init = t;
        l->last = t;
	}

// Assembly:
movq 0x20(%rsi), %rax
movq 0x20(%rax), %rcx
movsd 0x10(%rcx), %xmm0
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rcx)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rcx)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x10(%rax)
cvtsi2sd %edx, %xmm0
movsd %xmm0, (%rax)
movsd %xmm0, 0x8(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
testq %rdx, %rdx
je 0x5144
movq %rdx, %r14
movq %rsi, %r15
movq %rbx, %rdi
callq 0x4440
movq 0x8(%rbx), %rsi
imulq %r14, %rsi
movq %rbx, %rdi
callq 0x44a0
decq %r14
je 0x5157
movq %rbx, %rdi
movq %r15, %rsi
callq 0x45a0
jmp 0x5132
leaq 0x1212c(%rip), %rsi     # 0x17277
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0x4120
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5167
movq %rax, %r14
movq %rbx, %rdi
callq 0x4170
movq %r14, %rdi
callq 0x4540
// File: /workspace/github_cpp_makefile_star2_O2/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, %r13
movq %rdi, %rbx
testl %r13d, %r13d
je 0x5212
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %r13, %rax
shrq $0x20, %rax
andl $0x1, %eax
cmpl $0x1, %r13d
setne %cl
testb %al, %cl
je 0x5227
leaq 0x120bc(%rip), %rsi     # 0x17277
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x4120
movl 0x8(%r14), %r8d
leaq -0x38(%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0xfeac
movl -0x2c(%rbp), %r15d
movl -0x38(%rbp), %eax
movl -0x34(%rbp), %r12d
xorl %r13d, %r13d
testl %eax, %eax
cmovgl %eax, %r13d
subl $0x1, %r13d
jb 0x5238
movq %r14, %rdi
movl %r15d, %esi
callq 0xff6a
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x42b0
addl %r12d, %r15d
jmp 0x51f1
leaq 0x1205e(%rip), %rsi     # 0x17277
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x4120
jmp 0x5238
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0xfe62
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x524c
movq %rax, %r14
movq %rbx, %rdi
callq 0x4170
movq %r14, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rcx, %r8
movq %rdx, %rax
movq %rdi, %rbx
leaq -0x18(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
movq (%rdx), %rdx
movq 0x8(%rax), %rcx
cmpq $0x2, %r8
je 0x52ae
cmpq $0x1, %r8
je 0x52a4
testq %r8, %r8
jne 0x52b8
movq %rbx, %rdi
callq 0x4440
jmp 0x52c4
movq %rbx, %rdi
callq 0xffd0
jmp 0x52c4
movq %rbx, %rdi
callq 0xfe62
jmp 0x52c4
movq 0x10(%rax), %r8
movq %rbx, %rdi
callq 0x517a
leaq -0x28(%rbp), %rdi
callq 0x4170
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4540
nop