LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, -0x11(%rbp)
je 0x48f0
movq -0x38(%rbp), %rdi
callq 0x52a0
testb $0x1, %al
jne 0x485b
jmp 0x48eb
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x40(%rbp)
subq $0x3, %rax
ja 0x48e9
movq -0x40(%rbp), %rax
leaq 0x47ea(%rip), %rcx      # 0x9060
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rdi
movb $0x1, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0x52c0
jmp 0x48e9
movq -0x38(%rbp), %rdi
movl $0x1, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x52f0
jmp 0x48e9
movq -0x38(%rbp), %rdi
movl $0x2, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x52f0
jmp 0x48e9
movq -0x38(%rbp), %rdi
callq 0x5310
testb $0x1, %al
jne 0x48cd
jmp 0x48e7
movq -0x38(%rbp), %rdi
callq 0x7bb0
movq -0x38(%rbp), %rdi
movb $0x0, -0x1d(%rbp)
leaq -0x1d(%rbp), %rsi
callq 0x5330
jmp 0x48e9
jmp 0x48eb
jmp 0x4979
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x48(%rbp)
subq $0x4, %rax
ja 0x4977
movq -0x48(%rbp), %rax
leaq 0x4741(%rip), %rcx      # 0x904c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rdi
movb $0x0, -0x1e(%rbp)
leaq -0x1e(%rbp), %rsi
callq 0x52c0
jmp 0x4977
movq -0x38(%rbp), %rdi
movl $0x0, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x52f0
jmp 0x4977
movq -0x38(%rbp), %rdi
movl $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x52f0
jmp 0x4977
movq -0x38(%rbp), %rdi
movb $0x1, -0x29(%rbp)
leaq -0x29(%rbp), %rsi
callq 0x5330
jmp 0x4977
movq -0x38(%rbp), %rdi
movb $0x1, -0x2a(%rbp)
leaq -0x2a(%rbp), %rsi
callq 0x5360
jmp 0x4979
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x7670
movq -0x38(%rbp), %rdi
addq $0x90, %rdi
callq 0x5390
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
addq $0x90, %rdi
callq 0x53f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x53c0
testb $0x1, %al
jne 0x4f9c
jmp 0x4fcc
leaq -0x18(%rbp), %rdi
callq 0x5440
addq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x5480
movq %rax, -0x30(%rbp)
jmp 0x4f75
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7970
movq -0x40(%rbp), %rdi
addq $0x90, %rdi
callq 0x5390
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
addq $0x90, %rdi
callq 0x53f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x53c0
testb $0x1, %al
jne 0x5044
jmp 0x5078
leaq -0x20(%rbp), %rdi
callq 0x5440
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x5480
movq %rax, -0x38(%rbp)
jmp 0x501d
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5680
movq -0x10(%rbp), %rdi
callq 0x56c0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x7aa0
movq -0x38(%rbp), %rdi
addq $0x90, %rdi
callq 0x5390
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
addq $0x90, %rdi
callq 0x53f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x53c0
testb $0x1, %al
jne 0x50f1
jmp 0x5131
leaq -0x18(%rbp), %rdi
callq 0x5440
addq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x56c0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x18(%rax)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x5480
movq %rax, -0x30(%rbp)
jmp 0x50ca
movq -0x10(%rbp), %rdi
callq 0x56e0
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0x50, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4260
movq -0x50(%rbp), %rax
leaq 0x63b8(%rip), %rcx      # 0xcd10
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x2c(%rax)
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x30(%rax)
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x34(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x98(%rax)
movl -0x8(%rbp), %ecx
movl %ecx, -0x38(%rbp)
movl -0x4(%rbp), %ecx
movl %ecx, -0x34(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x8(%rbp), %ecx
movl %ecx, -0x40(%rbp)
movl -0x4(%rbp), %ecx
movl %ecx, -0x3c(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
callq 0x3100
movl $0x13a, %ecx            # imm = 0x13A
cltd
idivl %ecx
movl %edx, %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x50(%rbp), %rax
cvtsi2ss %ecx, %xmm0
movss %xmm0, 0x18(%rax)
movl 0x30(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x69f7
movq -0x50(%rbp), %rax
movss 0x268f(%rip), %xmm0     # 0x907c
movss %xmm0, 0x98(%rax)
jmp 0x6a0b
movq -0x50(%rbp), %rax
movss 0x2675(%rip), %xmm0     # 0x9078
movss %xmm0, 0x98(%rax)
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
movss (%rcx), %xmm0
movss %xmm0, 0x1c(%rax)
movq -0x20(%rbp), %rcx
movss (%rcx), %xmm0
movss %xmm0, 0x20(%rax)
callq 0x3100
movl $0xff, %ecx
cltd
idivl %ecx
movb %dl, %al
movb %al, -0x44(%rbp)
callq 0x3100
movl $0xff, %ecx
cltd
idivl %ecx
movb %dl, %al
movb %al, -0x43(%rbp)
callq 0x3100
movq -0x50(%rbp), %rdi
movl $0xff, %ecx
cltd
idivl %ecx
movb %dl, %al
movb %al, -0x42(%rbp)
movb $0x0, -0x41(%rbp)
movl -0x44(%rbp), %eax
movl %eax, 0x38(%rdi)
callq 0x6a80
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd 0x25e4(%rip), %xmm0     # 0x9080
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0x6b0d
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x3100
movsd -0x30(%rbp), %xmm0
movl $0x64, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rax
cvtsi2sd %edx, %xmm1
movsd 0x25b6(%rip), %xmm2     # 0x9090
divsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd 0x259e(%rip), %xmm1     # 0x9088
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movslq -0x14(%rbp), %rcx
movsd %xmm0, 0x40(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6aa8
movq -0x28(%rbp), %rax
movsd 0x40(%rax), %xmm0
movsd %xmm0, 0x90(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tkaczenko[P]asteroids-clone/src/Rock.cpp
// Function: Rock::trace()
void Rock::trace()
{
    switch (type) {
    case BIG_ROCK:
        generate(ROCK_BIG_RADIUS, angle);
        break;
    case MED_ROCK:
        generate(ROCK_MED_RADIUS, angle);
        break;
    case SMALL_ROCK:
        generate(ROCK_SMALL_RADIUS, angle);
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x34(%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x259, %eax            # imm = 0x259
je 0x6b7b
jmp 0x6b63
movl -0xc(%rbp), %eax
subl $0x25a, %eax            # imm = 0x25A
je 0x6b94
jmp 0x6b6f
movl -0xc(%rbp), %eax
subl $0x25b, %eax            # imm = 0x25B
je 0x6bad
jmp 0x6bc4
movq -0x18(%rbp), %rdi
movss 0x18(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movl $0x32, %esi
callq 0x6bd0
jmp 0x6bc4
movq -0x18(%rbp), %rdi
movss 0x18(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movl $0x19, %esi
callq 0x6bd0
jmp 0x6bc4
movq -0x18(%rbp), %rdi
movss 0x18(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movl $0xc, %esi
callq 0x6bd0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jg 0x6cb1
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll %ecx
cvtsi2sd %ecx, %xmm0
movsd 0x248e(%rip), %xmm1     # 0x90a0
mulsd %xmm1, %xmm0
movsd 0x247a(%rip), %xmm1     # 0x9098
divsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movslq -0x1c(%rbp), %rcx
movsd 0x40(%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x3400
movq -0x40(%rbp), %rcx
cvtsi2sdl -0xc(%rbp), %xmm1
mulsd %xmm1, %xmm0
mulsd -0x30(%rbp), %xmm0
cvttsd2si %xmm0, %eax
addl 0x10(%rcx), %eax
movl %eax, -0x34(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x30d0
movq -0x40(%rbp), %rax
cvtsi2sdl -0xc(%rbp), %xmm1
mulsd %xmm1, %xmm0
mulsd -0x30(%rbp), %xmm0
cvttsd2si %xmm0, %ecx
addl 0x14(%rax), %ecx
movl %ecx, -0x38(%rbp)
movl -0x34(%rbp), %edx
movslq -0x1c(%rbp), %rcx
movl %edx, 0x9c(%rax,%rcx,8)
movl -0x38(%rbp), %edx
movslq -0x1c(%rbp), %rcx
movl %edx, 0xa0(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6bf3
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cvtsi2ssl 0x8(%rax), %xmm1
movss 0x1c(%rax), %xmm0
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm2
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, 0x10(%rax)
cvtsi2ssl 0xc(%rax), %xmm1
movss 0x20(%rax), %xmm0
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm2
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, 0x14(%rax)
cmpl $0x320, 0x10(%rax)      # imm = 0x320
jle 0x6d4d
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
subl $0x320, %ecx            # imm = 0x320
movl %ecx, 0x10(%rax)
jmp 0x6d69
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jge 0x6d67
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x320, %ecx            # imm = 0x320
movl %ecx, 0x10(%rax)
jmp 0x6d69
movq -0x18(%rbp), %rax
cmpl $0x258, 0x14(%rax)      # imm = 0x258
jle 0x6d88
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
subl $0x258, %ecx            # imm = 0x258
movl %ecx, 0x14(%rax)
jmp 0x6dd2
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jge 0x6da4
movq -0x18(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x258, %ecx            # imm = 0x258
movl %ecx, 0x14(%rax)
jmp 0x6dd0
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x6db8
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x6dce
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
subl $0x14, %ecx
movl %ecx, 0x10(%rax)
movl 0x14(%rax), %ecx
subl $0x14, %ecx
movl %ecx, 0x14(%rax)
jmp 0x6dd0
jmp 0x6dd2
movq -0x18(%rbp), %rax
movss 0x98(%rax), %xmm0
addss 0x18(%rax), %xmm0
movss %xmm0, 0x18(%rax)
movl 0x10(%rax), %ecx
movl %ecx, 0x8(%rax)
movl 0x14(%rax), %ecx
movl %ecx, 0xc(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4260
movq -0x60(%rbp), %rdi
leaq 0x5e41(%rip), %rax      # 0xcd68
movq %rax, (%rdi)
movq $0x0, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
addq $0x40, %rdi
movq %rdi, -0x68(%rbp)
callq 0x7e40
movq -0x60(%rbp), %rax
movq $0x0, 0x70(%rax)
movq $0x0, 0x78(%rax)
movl $0x0, 0x80(%rax)
movl $0x0, 0x84(%rax)
movb $0x1, 0x88(%rax)
movb $0x0, 0x89(%rax)
movb $0x1, 0x8a(%rax)
movl $0x0, 0x8c(%rax)
movl $0x190, -0x10(%rbp)     # imm = 0x190
movl $0x12c, -0xc(%rbp)      # imm = 0x12C
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x190, -0x18(%rbp)     # imm = 0x190
movl $0x12c, -0x14(%rbp)     # imm = 0x12C
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x28, %edi
callq 0x3040
movq %rax, -0x58(%rbp)
jmp 0x6fca
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x70(%rax)
movl $0x18, %edi
callq 0x3040
movq %rax, -0x70(%rbp)
jmp 0x6fe6
movq -0x60(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, 0x78(%rax)
movl $0x30, %edi
callq 0x3040
movq %rax, -0x78(%rbp)
jmp 0x7002
movq -0x60(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, 0x38(%rax)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x33f0
movq -0x80(%rbp), %rdx
leaq 0x20a2(%rip), %rsi      # 0x90c8
leaq -0x48(%rbp), %rdi
callq 0x3350
jmp 0x7031
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x70e0
movq %rax, -0x88(%rbp)
jmp 0x7047
movq -0x60(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, 0x30(%rax)
leaq -0x48(%rbp), %rdi
callq 0x31b0
leaq -0x49(%rbp), %rdi
callq 0x3330
movq -0x60(%rbp), %rdi
movl $0x0, 0x1c(%rdi)
movl $0x0, 0x20(%rdi)
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x7084
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x70c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x70be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31b0
leaq -0x49(%rbp), %rdi
callq 0x3330
movq -0x68(%rbp), %rdi
callq 0x7e60
movq -0x20(%rbp), %rdi
callq 0x33e0
nopl (%rax)
// File: 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
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movq %rdi, -0x258(%rbp)
movl $0x8, %edx
callq 0x33b0
movq -0x258(%rbp), %rdi
callq 0x33a0
movb %al, -0x24d(%rbp)
jmp 0x7123
movb -0x24d(%rbp), %al
testb $0x1, %al
jne 0x7132
jmp 0x72a9
leaq -0x220(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x31a0
jmp 0x7147
leaq -0x220(%rbp), %rdi
leaq -0x234(%rbp), %rsi
callq 0x31a0
jmp 0x715c
movslq -0x230(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3040
movq %rax, -0x260(%rbp)
jmp 0x7187
movq -0x260(%rbp), %rax
movq %rax, -0x240(%rbp)
movl $0x0, -0x244(%rbp)
movl -0x244(%rbp), %eax
cmpl -0x230(%rbp), %eax
jge 0x7284
movslq -0x234(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3040
movq %rax, -0x268(%rbp)
jmp 0x71dc
movq -0x268(%rbp), %rdx
movq -0x240(%rbp), %rax
movslq -0x244(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x248(%rbp)
movl -0x248(%rbp), %eax
cmpl -0x234(%rbp), %eax
jge 0x726e
movq -0x240(%rbp), %rax
movslq -0x244(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x248(%rbp), %rcx
leaq (%rax,%rcx,4), %rsi
leaq -0x220(%rbp), %rdi
callq 0x31a0
jmp 0x7238
jmp 0x723a
movl -0x248(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x248(%rbp)
jmp 0x71ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x30f0
jmp 0x731e
jmp 0x7270
movl -0x244(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x244(%rbp)
jmp 0x719f
leaq -0x220(%rbp), %rdi
callq 0x30c0
jmp 0x7292
movq -0x240(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x24c(%rbp)
jmp 0x7305
movq 0x5d28(%rip), %rdi      # 0xcfd8
leaq 0x1e28(%rip), %rsi      # 0x90df
callq 0x32e0
movq %rax, -0x270(%rbp)
jmp 0x72c5
movq -0x270(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3260
movq %rax, -0x278(%rbp)
jmp 0x72de
movq -0x278(%rbp), %rdi
movq 0x5cdc(%rip), %rsi      # 0xcfc8
callq 0x3320
jmp 0x72f3
movq $0x0, -0x8(%rbp)
movl $0x1, -0x24c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x30f0
movq -0x8(%rbp), %rax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x33e0
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x5a0d(%rip), %rcx      # 0xcd58
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x70(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x7369
movq -0x10(%rbp), %rdi
callq 0x3340
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x7384
movq -0x20(%rbp), %rdi
callq 0x3340
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x739f
movq -0x28(%rbp), %rdi
callq 0x3340
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x73ba
movq -0x30(%rbp), %rdi
callq 0x3340
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x7e60
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cvtsi2ssl 0x8(%rax), %xmm1
movss 0x1c(%rax), %xmm0
movq -0x10(%rbp), %rcx
mulss (%rcx), %xmm0
movq -0x18(%rbp), %rcx
movss (%rcx), %xmm2
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, 0x10(%rax)
cvtsi2ssl 0xc(%rax), %xmm1
movss 0x20(%rax), %xmm0
movq -0x10(%rbp), %rcx
mulss (%rcx), %xmm0
movq -0x18(%rbp), %rcx
movss (%rcx), %xmm2
movd %xmm0, %ecx
xorl $0x80000000, %ecx       # imm = 0x80000000
movd %ecx, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movl %ecx, 0x14(%rax)
testb $0x1, 0x88(%rax)
je 0x7a0e
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
jmp 0x7a17
movq -0x38(%rbp), %rdi
callq 0x7a80
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
callq 0x54e0
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
callq 0x5540
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5510
testb $0x1, %al
jne 0x7a4c
jmp 0x7a7a
leaq -0x20(%rbp), %rdi
callq 0x5570
movq %rax, %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4140
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x5620
movq %rax, -0x30(%rbp)
jmp 0x7a28
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl $0xff, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x3360
movq -0x30(%rbp), %rax
testb $0x1, 0x88(%rax)
je 0x7ba9
movq -0x30(%rbp), %rax
testb $0x1, 0x89(%rax)
je 0x7b32
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x70(%rax), %rsi
movl $0x5, %edx
callq 0x31c0
movq -0x10(%rbp), %rdi
movl $0xff, %edx
xorl %r8d, %r8d
movl %edx, %esi
movl %r8d, %ecx
callq 0x3360
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x78(%rax), %rsi
movl $0x3, %edx
callq 0x31c0
jmp 0x7b48
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x70(%rax), %rsi
movl $0x5, %edx
callq 0x31c0
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
callq 0x54e0
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
callq 0x5540
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5510
testb $0x1, %al
jne 0x7b7d
jmp 0x7ba7
leaq -0x18(%rbp), %rdi
callq 0x5570
movq %rax, %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x41d0
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x5620
movq %rax, -0x28(%rbp)
jmp 0x7b59
jmp 0x7ba9
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x2d0, %rsp            # imm = 0x2D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2b8(%rbp)
movq 0x30(%rdi), %rax
movq (%rax), %rsi
movq %rsi, %rdx
addq $0x4, %rdx
movq %rsi, %rcx
addq $0x8, %rcx
movq %rsi, %r8
addq $0xc, %r8
callq 0x75d0
movq %rax, %rcx
movq -0x2b8(%rbp), %rax
movq %rcx, -0x10(%rbp)
movss 0x1c(%rax), %xmm1
movss 0x24(%rax), %xmm0
movss 0x14ad(%rip), %xmm2     # 0x90b8
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movss 0x20(%rax), %xmm1
movss 0x28(%rax), %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31e0
movq -0x2b8(%rbp), %rax
leaq -0x190(%rbp), %rdi
movl 0x8c(%rax), %esi
callq 0x33d0
jmp 0x7c56
leaq -0x1f0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x32d0
jmp 0x7c6b
leaq 0x1466(%rip), %rsi      # 0x90d8
leaq -0x1d0(%rbp), %rdi
leaq -0x1f0(%rbp), %rdx
callq 0x51a0
jmp 0x7c87
leaq -0x1f0(%rbp), %rdi
callq 0x31b0
movq -0x2b8(%rbp), %r9
movq -0x10(%rbp), %rax
movq %rax, -0x238(%rbp)
movl $0x25c, -0x23c(%rbp)    # imm = 0x25C
addq $0x8c, %r9
movq -0x238(%rbp), %rsi
leaq -0x230(%rbp), %rdi
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
leaq -0x23c(%rbp), %r8
callq 0x3f40
jmp 0x7cda
movq -0x2b8(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x2c0(%rbp)
leaq -0x2a0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
leaq -0x230(%rbp), %rdx
callq 0x7f00
jmp 0x7d08
movq -0x2c0(%rbp), %rdi
leaq -0x2a0(%rbp), %rsi
callq 0x7ec0
movb %dl, -0x2c9(%rbp)
movq %rax, -0x2c8(%rbp)
jmp 0x7d2a
movb -0x2c9(%rbp), %al
movq -0x2c8(%rbp), %rcx
movq %rcx, -0x2b0(%rbp)
movb %al, -0x2a8(%rbp)
leaq -0x2a0(%rbp), %rdi
callq 0x7f40
movq -0x2b8(%rbp), %rax
movl 0x8c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8c(%rax)
leaq -0x230(%rbp), %rdi
callq 0x4000
leaq -0x1d0(%rbp), %rdi
callq 0x31b0
leaq -0x1a0(%rbp), %rdi
callq 0x3210
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x7e25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x31b0
jmp 0x7e25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x7e19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x7e0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x2a0(%rbp), %rdi
callq 0x7f40
leaq -0x230(%rbp), %rdi
callq 0x4000
leaq -0x1d0(%rbp), %rdi
callq 0x31b0
leaq -0x1a0(%rbp), %rdi
callq 0x3210
movq -0x1a8(%rbp), %rdi
callq 0x33e0
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x7a13ac(%rax)
movl $0x0, 0x7a13a8(%rax)
movl $0x14, 0x19c(%rax)
movl 0x2c(%rsp), %ecx
movl %ecx, 0x190(%rax)
movl 0x28(%rsp), %ecx
movl %ecx, 0x194(%rax)
movl $0x0, 0x24(%rsp)
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0x194(%rcx), %eax
jge 0x3564
movq 0x8(%rsp), %rax
movslq 0x190(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rdx
movq 0x8(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq %rdx, 0xf0(%rax,%rcx,8)
movslq 0x24(%rsp), %rcx
movq 0xf0(%rax,%rcx,8), %rdi
movslq 0x190(%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x20c0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x34e5
movq 0x8(%rsp), %rax
movl $0xffff, 0x198(%rax)    # imm = 0xFFFF
movl $0x0, 0x20(%rsp)
movq 0x8(%rsp), %rcx
movl 0x20(%rsp), %eax
cmpl 0x194(%rcx), %eax
jge 0x35e9
movl $0x4, %edi
callq 0x2150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movl 0x20(%rsp), %esi
addl $0x3e8, %esi            # imm = 0x3E8
callq 0x2410
jmp 0x35b1
movq 0x8(%rsp), %rax
movq (%rsp), %rdx
movslq 0x20(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x357b
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x2130
jmp 0x35ee
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x2220
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
cvtsi2sdl 0x198(%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x194(%rcx), %eax
jge 0x3b7c
movq 0x20(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x20a0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl %eax, %edx
callq 0x2450
movq 0x20(%rsp), %rdi
xorl %edx, %edx
divl 0x190(%rdi)
movslq 0x2c(%rsp), %rax
movl %edx, 0xa0(%rdi,%rax,4)
movl 0x190(%rdi), %eax
imull 0x2c(%rsp), %eax
movslq 0x2c(%rsp), %rcx
addl 0xa0(%rdi,%rcx,4), %eax
movl %eax, 0x28(%rsp)
movslq 0x28(%rsp), %rax
movq 0x1a8(%rdi,%rax,8), %rsi
movl 0x44(%rsp), %edx
movl 0x2c(%rsp), %ecx
movslq 0x2c(%rsp), %rax
movl 0xa0(%rdi,%rax,4), %r8d
callq 0x4280
movq 0x20(%rsp), %rcx
movslq 0x2c(%rsp), %rax
movq 0xf0(%rcx,%rax,8), %rax
movslq 0x2c(%rsp), %rdx
movslq 0xa0(%rcx,%rdx,4), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm1
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3b54
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x3b60
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3a62
movsd 0x38(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: shuhaosun[P]Splitter-Windowed-CountMin/./Splitter.h
// Function: Splitter::ListInsert(Node*, int, int, int)
int ListInsert(DLNode *head, int a, int b, int x)
	{
		DLNode *p,*s;
		p = head->prior;

		s = (DLNode *)malloc(sizeof(DLNode));
		s->init = a;
		s->last = b;
		s->count = x;

		s->prior = p;
		s->next = p->next;
		p->next->prior = s;
		p->next = s;
//		printf("p->next->init= %f\n", p->next->init);
//		printf("p->next->last= %f\n", p->next->last);
		memoryusage = memoryusage + 2*12 + 16;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x28, %edi
callq 0x21b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
cvtsi2sdl 0x24(%rsp), %xmm0
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rcx)
cvtsi2sdl 0x20(%rsp), %xmm0
movq 0x8(%rsp), %rcx
movsd %xmm0, 0x8(%rcx)
cvtsi2sdl 0x1c(%rsp), %xmm0
movq 0x8(%rsp), %rcx
movsd %xmm0, 0x10(%rcx)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rdx, 0x20(%rcx)
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rdx
movq 0x8(%rsp), %rcx
movq %rdx, 0x18(%rcx)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq %rdx, 0x20(%rcx)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rdx, 0x18(%rcx)
movl 0x7a13ac(%rax), %ecx
addl $0x18, %ecx
addl $0x10, %ecx
movl %ecx, 0x7a13ac(%rax)
ud2
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x20(%rsp), %rax
movsd (%rax), %xmm1
movq 0x28(%rsp), %rax
subsd (%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x20(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq 0x20(%rsp), %rax
subsd (%rax), %xmm1
movsd 0x19da(%rip), %xmm2     # 0x6068
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
jbe 0x46be
movsd 0x10(%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x46d0
movsd 0x8(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x46f5
jp 0x46f5
movsd 0x18(%rsp), %xmm0
leaq 0x1b44(%rip), %rdi      # 0x6232
movb $0x1, %al
callq 0x2040
movsd 0x18(%rsp), %xmm0
addq $0x38, %rsp
retq
// File: 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 %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq -0x28(%rsp), %rax
addsd 0x10(%rax), %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x28(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x28(%rsp), %rax
movsd 0x18ff(%rip), %xmm0     # 0x6068
movsd %xmm0, 0x10(%rax)
cvtsi2sdl -0x14(%rsp), %xmm0
movq -0x28(%rsp), %rax
movsd %xmm0, (%rax)
cvtsi2sdl -0x14(%rsp), %xmm0
movq -0x28(%rsp), %rax
movsd %xmm0, 0x8(%rax)
retq
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
ja 0x7d19
leaq -0x19(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x67f0
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x355d3(%rip), %rsi     # 0x3d2bd
callq 0x7c70
jmp 0x7cf1
leaq -0x19(%rbp), %rdi
callq 0x6510
jmp 0x7d9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x6510
jmp 0x7da4
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
movb $0x0, -0x2d(%rbp)
callq 0xa560
movq -0x48(%rbp), %rdi
callq 0x6350
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rax
imulq %rax, %rsi
callq 0x6700
jmp 0x7d49
jmp 0x7d4b
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x7d85
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x65f0
jmp 0x7d6c
jmp 0x7d4b
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x7db0
jmp 0x7da4
movb $0x1, -0x2d(%rbp)
testb $0x1, -0x2d(%rbp)
jne 0x7d98
movq -0x48(%rbp), %rdi
callq 0x7db0
jmp 0x7d9a
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x67e0
nopl (%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2bf10
leaq -0x18(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x2bf30
movq -0xb0(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x48(%rbp)
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x48(%rbp)
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
callq 0x2bf50
movq %rax, %rcx
movq %rcx, -0xa8(%rbp)
testq %rax, %rax
je 0x81a9
jmp 0x8188
movq -0xa8(%rbp), %rax
subq $0x1, %rax
je 0x81e4
jmp 0x8197
movq -0xa8(%rbp), %rax
subq $0x2, %rax
je 0x8211
jmp 0x824d
movq -0xb8(%rbp), %rsi
movq -0xc8(%rbp), %rdi
callq 0xa560
jmp 0x81be
movl $0x1, -0x70(%rbp)
jmp 0x829f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7db0
jmp 0x82b8
movq -0xb8(%rbp), %rsi
movq -0xc8(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdx
callq 0x2bf70
jmp 0x8205
movl $0x1, -0x70(%rbp)
jmp 0x829f
movq -0xb8(%rbp), %rsi
movq -0xc8(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdx
movq -0x88(%rbp), %rcx
callq 0x2ae90
jmp 0x8244
movl $0x1, -0x70(%rbp)
jmp 0x829f
movq -0xb8(%rbp), %rsi
movq -0xc8(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x90(%rbp), %rdx
movq -0x98(%rbp), %rcx
movq -0xa0(%rbp), %r8
callq 0x7e30
jmp 0x8298
movl $0x1, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7db0
movq -0xc0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x67e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xa560
cmpb $0x0, 0x515d7(%rip)     # 0x59908
jne 0x8384
leaq 0x515ce(%rip), %rdi     # 0x59908
callq 0x6820
cmpl $0x0, %eax
je 0x8384
leaq 0x5159d(%rip), %rdi     # 0x598e8
leaq 0x35803(%rip), %rsi     # 0x3db55
movl $0x10, %edx
callq 0x7ba0
jmp 0x835e
leaq -0x725(%rip), %rdi      # 0x7c40
leaq 0x5157c(%rip), %rsi     # 0x598e8
leaq 0x510f5(%rip), %rdx     # 0x59468
callq 0x6430
leaq 0x51589(%rip), %rdi     # 0x59908
callq 0x6310
leaq 0x5155d(%rip), %rsi     # 0x598e8
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq 0x2c070
movb %al, -0x71(%rbp)
jmp 0x839b
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x83a4
jmp 0x83f3
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdi
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
leaq -0x48(%rbp), %rdx
callq 0x2c0c0
jmp 0x83c2
movl $0x1, -0x58(%rbp)
jmp 0x8418
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq 0x5152a(%rip), %rdi     # 0x59908
callq 0x6300
jmp 0x842e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x842e
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdi
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
leaq -0x48(%rbp), %rdx
callq 0x2c3c0
jmp 0x8411
movl $0x1, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7db0
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x7db0
movq -0x50(%rbp), %rdi
callq 0x67e0
// File: 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
subq $0x90, %rsp
movq %rcx, -0x70(%rbp)
movq %rdx, -0x60(%rbp)
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq $0x0, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
callq 0xa560
movq -0x60(%rbp), %rdi
callq 0x6350
movq -0x70(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x6350
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdx
callq 0x6890
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x30(%rbp)
movb %al, -0x79(%rbp)
je 0x8635
movq -0x68(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x6350
movq -0x88(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x79(%rbp)
ja 0x8635
cmpq $0x0, -0x28(%rbp)
seta %al
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x863e
jmp 0x86b3
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x6150
jmp 0x8655
movq -0x48(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x8696
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
movq -0x30(%rbp), %rdx
callq 0x6890
movq %rax, -0x30(%rbp)
jmp 0x86a2
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x7db0
jmp 0x86d3
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x85f6
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x86c6
movq -0x68(%rbp), %rdi
callq 0x7db0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x67e0
nopl (%rax)
// File: ChanTsune[P]py_string/./py_string.hpp
// Function: void py::basic_string<char>::split<std::deque<py::basic_string<char>, std::allocator<py::basic_string<char>>>>(std::deque<py::basic_string<char>, std::allocator<py::basic_string<char>>>&, py::basic_string<char>, unsigned long) const
void basic_string<_Elme>::split(_Iterable &result, basic_string<_Elme> sep,
                                size_t maxsplit) const
{
  if (sep.empty())
    return this->split(result, maxsplit);
  if (result.size() != 0)
    result.clear();
  size_t index, pre_index = 0, sep_len = sep.size();
  for (; maxsplit--;) {
    index = this->find(sep, pre_index);
    if (index == std::basic_string<_Elme>::npos)
      break;
    result.push_back(this->substr(pre_index, index - pre_index));
    pre_index = index + sep_len;
  }
  result.push_back(this->substr(pre_index));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0xa0(%rbp)
movq %rdi, %rax
movq -0xa0(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x6770
testb $0x1, %al
jne 0x8759
jmp 0x8772
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3a760
jmp 0x88a3
movq -0x10(%rbp), %rdi
callq 0x3a9b0
cmpq $0x0, %rax
je 0x878a
movq -0x10(%rbp), %rdi
callq 0x3a9e0
movq -0x98(%rbp), %rdi
movq $0x0, -0x30(%rbp)
callq 0x6350
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8852
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
movq -0x30(%rbp), %rdx
callq 0x6890
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x87df
jmp 0x8852
movq -0x90(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq %rdx, %rcx
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x2b2d0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x3aa20
jmp 0x8821
leaq -0x58(%rbp), %rdi
callq 0x7db0
movq -0x28(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x87a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x7db0
jmp 0x88c4
movq -0x90(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x30(%rbp), %rdx
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq $-0x1, %rcx
callq 0x2b2d0
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x3aa20
jmp 0x8897
leaq -0x88(%rbp), %rdi
callq 0x7db0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x7db0
movq -0x60(%rbp), %rdi
callq 0x67e0
nopl (%rax)