LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::drawBoard(int, int, int)
void DNWindow::drawBoard(int start_Y, int start_X, int size)
{
    this->clearScreen();
    this->drawHeaderWithGuide(string("TicTacToe - press 'x' to trigger turn"));
    this->drawHeader();
    this->refreshDN();
    
    struct winsize w;
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
    

    move(start_Y, start_X);

    for (int y = 0; y < size; y++) {
        for (int x = 0; x < size * 2; x++) {
            mvaddch(start_Y + y, start_X + x, ACS_CKBOARD);
        }
    }

    this->refreshDN();
    this->moveToCenter();
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq %rsi, 0x18(%rsp)
callq 0x34a0
callq 0x3480
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x13a0(%rip), %rsi      # 0x9532
leaq 0x13be(%rip), %rdx      # 0x9557
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x404c
movq %r15, %rsi
callq 0x779a
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x81c5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
callq 0x7692
callq 0x3480
xorl %r13d, %r13d
leaq 0x40(%rsp), %rdx
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
xorl %eax, %eax
callq 0x33e0
movq 0x18(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x31f0
cmpl $0x0, 0x8(%rsp)
jle 0x825a
movq 0x8(%rsp), %rax
addl %eax, %eax
movl %eax, 0x14(%rsp)
movq 0x4dc1(%rip), %r14      # 0xcfd0
movq 0x4d8a(%rip), %rbx      # 0xcfa0
movq 0x18(%rsp), %rax
leal (%rax,%r13), %r15d
movl 0x4(%rsp), %r12d
movl 0x14(%rsp), %ebp
movq (%r14), %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x3320
cmpl $-0x1, %eax
je 0x8249
movq (%r14), %rdi
movl 0x184(%rbx), %esi
callq 0x30e0
incl %r12d
decl %ebp
jne 0x8228
incl %r13d
cmpl 0x8(%rsp), %r13d
jne 0x8216
callq 0x3480
callq 0x83fa
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x828d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::terminateWithErrorMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void DNWindow::terminateWithErrorMessage(string  message)
{
    DNLogService::sharedObject() << "ERROR => " << message << "\n";
    DNWindow::getInstance().clearScreen();
    DNWindow::getInstance().middleString(message, 13);
    DNWindow:: getInstance().refreshDN();
    sleep(3);
    DNWindow::getInstance().terminate();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
callq 0x3f98
leaq 0xde5(%rip), %rsi       # 0x90af
movq %rax, %rdi
callq 0x4ca4
movq %rax, %r14
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x3fb6
movq %r14, %rdi
movq %r15, %rsi
callq 0x4de0
leaq 0x1206(%rip), %rsi      # 0x950e
movq %rax, %rdi
callq 0x4ca4
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x8327
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x32f0
callq 0x39ee
callq 0x34a0
callq 0x3480
callq 0x39ee
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3fb6
leaq 0x40(%rsp), %r14
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x33e0
movzwl 0x2(%r14), %esi
subq 0x8(%rbx), %rsi
shrq %rsi
movq (%rbx), %rcx
leaq 0x1133(%rip), %rdx      # 0x94bc
movl $0xd, %edi
xorl %eax, %eax
callq 0x33d0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x83ab
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x32f0
callq 0x39ee
callq 0x3480
movl $0x3, %edi
callq 0x3230
callq 0x39ee
callq 0x3390
xorl %edi, %edi
callq 0x33a0
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x83e1
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x83f2
movq (%r12), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::startLocalGameHumanVsCPU(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool DNWindow::startLocalGameHumanVsCPU(string &nameOfPlayerOne)
{
    //    noraw();a
    struct winsize w;
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
    clearScreen();
    drawHeader();

    middleString("Please enter name of human player: ", w.ws_row / 2);
    
    while(true){
        inputString(nameOfPlayerOne);
        if (!nameOfPlayerOne.length()) middleString("Name cannot be empty, try again: ", w.ws_row / 2);
        else break;
    }
    
    clearScreen();
    drawHeader();
    return true;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
leaq 0x30(%rsp), %r14
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x33e0
callq 0x34a0
callq 0x3480
callq 0x7692
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe30(%rip), %rsi       # 0x95c3
leaq 0xe4c(%rip), %rdx       # 0x95e6
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x404c
movzwl (%r14), %ebp
shrl %ebp
leaq 0x8(%rsp), %r14
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x33e0
movzwl 0x2(%r14), %esi
subq 0x8(%r12), %rsi
shrq %rsi
movq (%r12), %rcx
leaq 0xcde(%rip), %rdx       # 0x94bc
movl %ebp, %edi
xorl %eax, %eax
callq 0x33d0
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x87fe
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rsi
callq 0x7da6
cmpq $0x0, 0x8(%rbx)
jne 0x88a4
leaq 0x20(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0xc95(%rip), %rbp       # 0x94bc
movq %r15, 0x10(%rsp)
movq %r12, %rdi
leaq 0xd46(%rip), %rsi       # 0x957c
leaq 0xd60(%rip), %rdx       # 0x959d
callq 0x404c
movzwl 0x30(%rsp), %r14d
shrl %r14d
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %r13, %rdx
xorl %eax, %eax
callq 0x33e0
movzwl 0xa(%rsp), %esi
subq 0x18(%rsp), %rsi
shrq %rsi
movq 0x10(%rsp), %rcx
movl %r14d, %edi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x33d0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x8895
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rsi
callq 0x7da6
cmpq $0x0, 0x8(%rbx)
je 0x8827
callq 0x34a0
callq 0x3480
callq 0x7692
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
jmp 0x88d6
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x88e6
movq (%r15), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::chooseTypeOfNetworkGame(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int DNWindow::chooseTypeOfNetworkGame(string &nameOfPlayer)
{
    string input;
    clearScreen();
    drawHeader();
    drawOptionsForNetworkGame();
    refreshDN();
    return executeOptionsForNetworkgame(nameOfPlayer);
    
    
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
callq 0x34a0
callq 0x3480
callq 0x7692
callq 0x897a
callq 0x3480
movq %rbx, %rsi
callq 0x8ae2
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x894d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x8971
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::drawOptionsForNetworkGame()
void DNWindow::drawOptionsForNetworkGame()
{
    refresh();
    struct winsize w;
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
    start_color();
    init_pair(1, COLOR_RED, COLOR_BLACK);

    mvprintw(w.ws_row / 3, w.ws_col / 10, "( ) Connect to Game");
    mvprintw(w.ws_row / 3 + 1, w.ws_col / 10, "( ) Create a game");
    
    mvprintw(w.ws_row / 3 + 6, w.ws_col / 10, "( ) Quit");
    

    mvaddch(w.ws_row / 3, w.ws_col / 10 + 1, '1');
    mvaddch(w.ws_row / 3 + 1, w.ws_col / 10 + 1, '2');
    mvaddch(w.ws_row / 3 + 6, w.ws_col / 10 + 1, 'Q');
    
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x3480
movq %rsp, %rbx
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x33e0
callq 0x3090
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3060
movzwl (%rbx), %eax
imull $0xaaab, %eax, %edi     # imm = 0xAAAB
shrl $0x11, %edi
movzwl 0x2(%rbx), %eax
imull $0xcccd, %eax, %esi     # imm = 0xCCCD
shrl $0x13, %esi
leaq 0xc17(%rip), %rdx       # 0x95e7
xorl %eax, %eax
callq 0x33d0
movzwl (%rbx), %eax
imull $0xaaab, %eax, %edi     # imm = 0xAAAB
shrl $0x11, %edi
incl %edi
movzwl 0x2(%rbx), %eax
imull $0xcccd, %eax, %esi     # imm = 0xCCCD
shrl $0x13, %esi
leaq 0xc02(%rip), %rdx       # 0x95fb
xorl %eax, %eax
callq 0x33d0
movzwl (%rbx), %eax
imull $0xaaab, %eax, %edi     # imm = 0xAAAB
shrl $0x11, %edi
addl $0x6, %edi
movzwl 0x2(%rbx), %eax
imull $0xcccd, %eax, %esi     # imm = 0xCCCD
shrl $0x13, %esi
leaq 0xa90(%rip), %rdx       # 0x94b3
xorl %eax, %eax
callq 0x33d0
movq 0x459f(%rip), %r14      # 0xcfd0
movq (%r14), %rdi
movzwl (%rbx), %eax
imull $0xaaab, %eax, %esi     # imm = 0xAAAB
shrl $0x11, %esi
movzwl 0x2(%rbx), %eax
imull $0xcccd, %eax, %edx     # imm = 0xCCCD
shrl $0x13, %edx
incl %edx
callq 0x3320
cmpl $-0x1, %eax
je 0x8a66
movq (%r14), %rdi
movl $0x31, %esi
callq 0x30e0
movq (%r14), %rdi
movzwl (%rsp), %eax
imull $0xaaab, %eax, %esi     # imm = 0xAAAB
shrl $0x11, %esi
incl %esi
movzwl 0x2(%rsp), %eax
imull $0xcccd, %eax, %edx     # imm = 0xCCCD
shrl $0x13, %edx
incl %edx
callq 0x3320
cmpl $-0x1, %eax
je 0x8a9f
movq (%r14), %rdi
movl $0x32, %esi
callq 0x30e0
movq (%r14), %rdi
movzwl (%rsp), %eax
imull $0xaaab, %eax, %esi     # imm = 0xAAAB
shrl $0x11, %esi
addl $0x6, %esi
movzwl 0x2(%rsp), %eax
imull $0xcccd, %eax, %edx     # imm = 0xCCCD
shrl $0x13, %edx
incl %edx
callq 0x3320
cmpl $-0x1, %eax
je 0x8ad9
movq (%r14), %rdi
movl $0x51, %esi
callq 0x30e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::executeOptionsForNetworkgame(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int DNWindow::executeOptionsForNetworkgame(string & input)
{
    
    
    drawCommandLine();
    refreshDN();
    inputString(input);
    
    
    if (atoi(input.c_str())  == 1 || atoi(input.c_str()) == 2) {
        return atoi(input.c_str());
    }else if (input == "Q" || input == "q") {
        terminate();
    }else{
        terminateWithErrorMessage(string("Wrong input"));
    }

    return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
callq 0x7c66
callq 0x3480
movq %rbx, %rsi
callq 0x7da6
movq (%rbx), %rdi
callq 0x3430
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x8b16
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0xa05(%rip), %rsi       # 0x9522
movq %rbx, %rdi
callq 0x30d0
testl %eax, %eax
je 0x8b3c
leaq 0x9f4(%rip), %rsi       # 0x9524
movq %rbx, %rdi
callq 0x30d0
testl %eax, %eax
jne 0x8b48
callq 0x3390
xorl %edi, %edi
callq 0x33a0
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xab5(%rip), %rsi       # 0x960d
leaq 0xab9(%rip), %rdx       # 0x9618
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x404c
movq %rbx, %rsi
callq 0x82b0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x8b8e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::drawSymbolBetter(DNCellState, int&, int&)
void DNWindow::drawSymbolBetter(DNCellState state, int& x, int& y)
{
    if (state == CROSS) {
        mvaddch(y, x, 'X');
        beep();
        moveRight();
        moveLeft();
        this->refreshDN();
    }
    else if (state == CIRCLE) {
        mvaddch(y, x, 'O');
        beep();
        moveRight();
        moveLeft();
        this->refreshDN();
    }
    else {
        terminateWithErrorMessage(string("Fatal Error"));
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %esi
je 0x8c01
cmpl $0x2, %esi
jne 0x8c48
movq 0x43e2(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
movl (%rcx), %esi
movl (%rdx), %edx
callq 0x3320
movl $0x58, %esi
jmp 0x8c19
movq 0x43c8(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
movl (%rcx), %esi
movl (%rdx), %edx
callq 0x3320
movl $0x4f, %esi
cmpl $-0x1, %eax
je 0x8c2d
movq 0x43ab(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
callq 0x30e0
callq 0x3080
callq 0x7d78
callq 0x7d46
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x3480
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x9c1(%rip), %rsi       # 0x9619
leaq 0x9c5(%rip), %rdx       # 0x9624
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x404c
movq %rbx, %rsi
callq 0x82b0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x8c8e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::drawSymbol(DNCellState, int&, int&)
void DNWindow::drawSymbol(DNCellState state, int & x, int &y)
{
    getsyx(y, x);
    if (state == CROSS) {
        addch('X');
        beep();
        moveRight();
        moveLeft();
    }
    else if (state == CIRCLE) {
        addch('O');
        beep();
        moveRight();
        moveLeft();
    }
    else {
        terminateWithErrorMessage(string("Fatal Error"));
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x4324(%rip), %rax      # 0xcfc8
movq (%rax), %rax
testq %rax, %rax
je 0x8cc8
cmpb $0x0, 0x1a(%rax)
je 0x8cbd
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%rdx)
movl %eax, (%rcx)
jmp 0x8cc8
movswl (%rax), %edi
movl %edi, (%rcx)
movswl 0x2(%rax), %eax
movl %eax, (%rdx)
movl $0x58, %eax
cmpl $0x2, %esi
je 0x8cdc
cmpl $0x1, %esi
jne 0x8d03
movl $0x4f, %eax
movq 0x42ed(%rip), %rcx      # 0xcfd0
movq (%rcx), %rdi
movl %eax, %esi
callq 0x30e0
callq 0x3080
callq 0x7d78
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x7d46
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x906(%rip), %rsi       # 0x9619
leaq 0x90a(%rip), %rdx       # 0x9624
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x404c
movq %rbx, %rsi
callq 0x82b0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x8d49
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::enterServerIPAdress(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void DNWindow::enterServerIPAdress(string& ip_address)
{

    struct winsize w;
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
    mvprintw(w.ws_row - 1, 0, "ENTER HOST IP ADDRESS> ");
    refreshDN();
    inputString(ip_address);
    

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsp, %r14
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x33e0
movzwl (%r14), %edi
decl %edi
leaq 0x8a8(%rip), %rdx       # 0x9625
xorl %esi, %esi
xorl %eax, %eax
callq 0x33d0
callq 0x3480
movq %rbx, %rsi
callq 0x7da6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/gai.c
// Function: main
int main(int argc, char **argv)
{
    if (argc == 1) usage("host... -- display getaddrinfo results");

    struct addrinfo crap, *gaip = NULL, *aip,
           hint = { AI_NUMERICSERV | AI_CANONNAME, AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP,
                    /*addrlen*/0, /*addr*/0, /*canonname*/0, /*next*/0 };

    while (*++argv) {
        gaip = &crap;
        int ret = getaddrinfo(*argv, 0, &hint, &gaip);
        if (ret)  {
            fprintf(stderr, "%s error:%d %s\n", *argv, ret, eainame[-ret]);
        } else if (gaip) {

            printf("%s %s\n", *argv, 
                    gaip->ai_canonname && strcmp(gaip->ai_canonname, *argv)
                        ? gaip->ai_canonname : "");

            for (aip = gaip; aip; aip = aip->ai_next) {
                IPSTR    ip = {};
                inet_ntop(aip->ai_family, 
                            aip->ai_family == AF_INET6 
                                ? (void*)&((struct sockaddr_in6*)aip->ai_addr)->sin6_addr
                                : (void*)&((struct sockaddr_in *)aip->ai_addr)->sin_addr, 
                            ip, sizeof(ip));
                printf("\t%s\n", ip);
            }

            freeaddrinfo(gaip);
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
cmpl $0x1, %edi
je 0x35a3
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x402, 0x10(%rsp)      # imm = 0x402
movabsq $0x600000001, %rax      # imm = 0x600000001
movq %rax, 0x18(%rsp)
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x358f
addq $0x8, %rbx
leaq 0x1ba5(%rip), %r15      # 0x503f
leaq 0x40(%rsp), %r13
leaq 0x1b95(%rip), %rbp      # 0x503b
leaq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %esi, %esi
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0x31b0
testl %eax, %eax
jne 0x3583
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x3570
movq (%rbx), %r12
movq 0x20(%rax), %r14
movq %r15, %rdx
testq %r14, %r14
je 0x34fa
movq %r14, %rdi
movq %r12, %rsi
callq 0x31f0
testl %eax, %eax
cmoveq %r15, %r14
movq %r14, %rdx
leaq 0x1b46(%rip), %rdi      # 0x5047
movq %r12, %rsi
xorl %eax, %eax
callq 0x3040
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x3569
xorps %xmm0, %xmm0
movups %xmm0, 0x5e(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movl 0x4(%r14), %edi
xorl %eax, %eax
cmpl $0xa, %edi
sete %al
movq 0x18(%r14), %rcx
leaq (%rcx,%rax,4), %rsi
addq $0x4, %rsi
movq %r13, %rdx
movl $0x2e, %ecx
callq 0x3130
movq %rbp, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x3040
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x3515
movq 0x8(%rsp), %rdi
jmp 0x356b
xorl %edi, %edi
callq 0x31c0
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x34a6
jmp 0x358f
movq %rbx, %rdi
movl %eax, %esi
callq 0x32e0
jmp 0x3570
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3316
// File: /workspace/github_cpp_makefile_star2_O3/zengfenfei[P]codility/src/CyclicRotation.cpp
// Function: main
int main() {
	int ints[] = { 3, 8, 9, 7, 6 };
	vector<int> a(ints, ints + sizeof(ints) / sizeof(int));
	vector<int> out = solution(a, 3);
	printVector(out);
	printVector(vector<int>());
	//9, 7, 6, 3, 8
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movaps 0xcc0(%rip), %xmm0      # 0x2040
leaq -0x5c(%rbp), %rdx
movaps %xmm0, -0x14(%rdx)
movl $0x6, -0x4(%rdx)
leaq -0x50(%rbp), %rbx
leaq -0x70(%rbp), %rsi
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
callq 0x151c
leaq -0x20(%rbp), %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq 0x123c
leaq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x155e
leaq -0x38(%rbp), %rdi
callq 0x12db
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x13df
movq -0x28(%rbp), %rsi
subq %rdi, %rsi
callq 0x1090
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x12db
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x140e
movq -0x10(%rbp), %rsi
subq %rdi, %rsi
callq 0x1090
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x1423
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x1090
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
jmp 0x144b
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x144e
movq -0x28(%rbp), %rsi
subq %rdi, %rsi
callq 0x1090
jmp 0x144e
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x1468
movq -0x10(%rbp), %rsi
subq %rdi, %rsi
callq 0x1090
jmp 0x1468
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x147d
movq -0x40(%rbp), %rsi
subq %rdi, %rsi
callq 0x1090
movq %rbx, %rdi
callq 0x10e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/document_graph.cpp
// Function: testDocarray(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int
testDocarray(const std::string& base_name)
{
  RLCSA rlcsa(base_name);
  if(!(rlcsa.isOk())) { return 4; }
  DocArray docarray(rlcsa, base_name, true);
  if(!(docarray.isOk())) { return 5; }

  rlcsa.printInfo();
  rlcsa.reportSize(true);
  docarray.reportSize(true);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x880, %rsp            # imm = 0x880
movq %rdi, %r14
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6a70
movl $0x4, %ebx
cmpb $0x1, (%r15)
jne 0x6268
movq %rsp, %rdi
leaq 0x50(%rsp), %rsi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x12336
movl $0x5, %ebx
cmpb $0x0, 0x48(%rsp)
je 0x6260
leaq 0x50(%rsp), %rdi
callq 0xa19a
leaq 0x50(%rsp), %rdi
movl $0x1, %esi
callq 0x9ef2
xorl %ebx, %ebx
movq %rsp, %rdi
movl $0x1, %esi
callq 0x142a2
movq %rsp, %rdi
callq 0x1264e
leaq 0x50(%rsp), %rdi
callq 0x7f6e
movl %ebx, %eax
addq $0x880, %rsp            # imm = 0x880
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x6291
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1264e
leaq 0x50(%rsp), %rdi
callq 0x7f6e
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/document_graph.cpp
// Function: buildIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int
buildIndex(const std::string& base_name, const std::string& prefix)
{
  RLCSA rlcsa(base_name);
  if(!(rlcsa.isOk())) { return 4; }
  DocArray docarray(rlcsa, base_name, false);
  if(!(docarray.isOk())) { return 5; }

  docarray.readRules(prefix, true);
  if(!(docarray.hasGrammar())) { return 6; }
  docarray.writeTo(base_name);

  rlcsa.printInfo();
  rlcsa.reportSize(true);
  docarray.reportSize(true);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x888, %rsp            # imm = 0x888
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x6a70
movl $0x4, %ebp
cmpb $0x1, (%r15)
jne 0x6352
leaq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x12336
movl $0x5, %ebp
cmpb $0x0, 0x50(%rsp)
je 0x6348
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x12ca4
movl $0x6, %ebp
cmpb $0x1, 0x51(%rsp)
jne 0x6348
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x140c4
leaq 0x58(%rsp), %rdi
callq 0xa19a
leaq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0x9ef2
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x142a2
leaq 0x8(%rsp), %rdi
callq 0x1264e
leaq 0x58(%rsp), %rdi
callq 0x7f6e
movl %ebp, %eax
addq $0x888, %rsp            # imm = 0x888
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x637e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1264e
leaq 0x58(%rsp), %rdi
callq 0x7f6e
movq %rbx, %rdi
callq 0x3460
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::STNode::~STNode()
STNode::~STNode()
{
  this->parent = 0;
  delete this->docs; this->docs = 0;
  delete this->child; this->child = 0;
  while(this->sibling != 0)
  {
    STNode* temp = this->sibling; this->sibling = this->sibling->sibling;
    temp->sibling = 0; delete temp;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, 0x10(%rdi)
movq 0x40(%rdi), %r14
testq %r14, %r14
je 0x111b2
movq (%r14), %rdi
testq %rdi, %rdi
je 0x111b2
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x3270
movl $0x18, %esi
movq %r14, %rdi
callq 0x3270
movq $0x0, 0x40(%rbx)
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x111d8
movq %r14, %rdi
callq 0x11186
movl $0x48, %esi
movq %r14, %rdi
callq 0x3270
movq $0x0, 0x18(%rbx)
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x1121d
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
movq $0x0, 0x20(%r14)
movq %r14, %rdi
callq 0x11186
movl $0x48, %esi
movq %r14, %rdi
callq 0x3270
jmp 0x111ed
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::STNode::addLeaves()
void
STNode::addLeaves()
{
  if(this->child == 0) { return; }

  usint expect = this->range.first;
  STNode* prev = 0;
  for(STNode* temp = this->child; temp != 0; temp = temp->sibling)
  {
    while(expect < temp->range.first) { prev = this->addLeaf(prev, temp, expect); expect++; }
    temp->addLeaves();
    expect = temp->range.second + 1;
    prev = temp;
  }

  while(expect < this->range.second + 1) { prev = this->addLeaf(prev, 0, expect); expect++; }
}

// Assembly:
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x113cb
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x18(%rdi), %r12
movq %rdi, (%rsp)
movl 0x4(%rdi), %eax
xorl %ebp, %ebp
movq (%rsp), %rbx
movq %rcx, %r14
cmpl 0x4(%rcx), %eax
jae 0x11338
movl %eax, %r15d
movq %r15, %r13
movabsq $0x100000001, %rax      # imm = 0x100000001
imulq %rax, %r13
movl $0x48, %edi
callq 0x3260
xorps %xmm0, %xmm0
leaq 0x20(%rbp), %rcx
testq %rbp, %rbp
movl $0x0, (%rax)
movq %r13, 0x4(%rax)
movq $0x0, 0x40(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movb $0x0, 0x38(%rax)
cmoveq %r12, %rcx
movq %rbx, 0x10(%rax)
movq %rax, (%rcx)
movq %r14, 0x20(%rax)
incq %r15
movl 0x4(%r14), %ecx
movabsq $0x100000001, %rdx      # imm = 0x100000001
addq %rdx, %r13
movq %rax, %rbp
cmpq %rcx, %r15
jb 0x112db
movq %r14, %rdi
callq 0x11296
movl 0x8(%r14), %edx
leal 0x1(%rdx), %eax
movq 0x20(%r14), %rcx
movq %r14, %rbp
testq %rcx, %rcx
jne 0x112bf
movq (%rsp), %rbp
movl 0x8(%rbp), %r12d
leal 0x1(%r12), %ecx
cmpl %ecx, %eax
movabsq $0x100000001, %rbx      # imm = 0x100000001
jae 0x113bd
movl %eax, %r15d
imulq %rbx, %r15
subl %edx, %r12d
xorl %r13d, %r13d
movl $0x48, %edi
callq 0x3260
movl $0x0, (%rax)
movq %r15, 0x4(%rax)
movq %r13, 0x40(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movb $0x0, 0x38(%rax)
movq %rbp, 0x10(%rax)
movq %rax, 0x20(%r14)
movq %r13, 0x20(%rax)
addq %rbx, %r15
movq %rax, %r14
decl %r12d
jne 0x1137f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::STNode::addLeaf(CSA::STNode*, CSA::STNode*, unsigned int)
STNode*
STNode::addLeaf(STNode* left, STNode* right, usint pos)
{
  STNode* leaf = new STNode(0, pair_type(pos, pos));
  leaf->parent = this;
  if(left == 0) { this->child = leaf; }
  else          { left->sibling = leaf; }
  leaf->sibling = right;
  return leaf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x48, %edi
callq 0x3260
movl %ebx, %ecx
movq %rcx, %rdx
shlq $0x20, %rdx
orq %rcx, %rdx
movl $0x0, (%rax)
movq %rdx, 0x4(%rax)
movq $0x0, 0x40(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movb $0x0, 0x38(%rax)
movq %r12, 0x10(%rax)
leaq 0x20(%r15), %rcx
addq $0x18, %r12
testq %r15, %r15
cmovneq %rcx, %r12
movq %rax, (%r12)
movq %r14, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::operator<<(std::ostream&, CSA::STNode const&)
std::ostream&
operator<<(std::ostream& stream, const STNode& data)
{
  stream << "(depth = " << data.string_depth << ", range = " << data.range << ", parent = " << data.parent;

  stream << ", siblings = (";
  for(STNode* curr = data.sibling; curr != 0; curr = curr->sibling)
  {
    if(curr != data.sibling) { stream << ", "; }
    stream << curr;
  }
  stream << ")";

  stream << ", children = (";
  for(STNode* curr = data.child; curr != 0; curr = curr->sibling)
  {
    if(curr != data.child) { stream << ", "; }
    stream << curr;
  }
  stream << ")";

  stream << ")";
  return stream;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xd31d(%rip), %rsi      # 0x1e976
movl $0x9, %edx
callq 0x32b0
movl (%r14), %esi
movq %rbx, %rdi
callq 0x3180
movq %rax, %r15
leaq 0xd308(%rip), %rsi      # 0x1e980
movl $0xa, %edx
movq %rax, %rdi
callq 0x32b0
leaq 0x4(%r14), %rsi
movq %r15, %rdi
callq 0x146e9
movq %rax, %r15
leaq 0xd2f0(%rip), %rsi      # 0x1e98b
movl $0xb, %edx
movq %rax, %rdi
callq 0x32b0
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x31e0
leaq 0xd2dc(%rip), %rsi      # 0x1e997
movl $0xe, %edx
movq %rbx, %rdi
callq 0x32b0
movq 0x20(%r14), %r15
testq %r15, %r15
je 0x11702
leaq 0xd389(%rip), %r12      # 0x1ea61
cmpq 0x20(%r14), %r15
je 0x116ee
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x32b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31e0
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0x116d8
leaq 0xcc32(%rip), %rsi      # 0x1e33b
movl $0x1, %edx
movq %rbx, %rdi
callq 0x32b0
leaq 0xd289(%rip), %rsi      # 0x1e9a6
movl $0xe, %edx
movq %rbx, %rdi
callq 0x32b0
movq 0x18(%r14), %r15
testq %r15, %r15
je 0x11764
leaq 0xd327(%rip), %r12      # 0x1ea61
cmpq 0x18(%r14), %r15
je 0x11750
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x32b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31e0
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0x1173a
leaq 0xcbd0(%rip), %r14      # 0x1e33b
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32b0
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::STNode::remove()
void
STNode::remove()
{
  if(this->child == 0 || this->parent == 0) { return; }  // Cannot remove root or leaves.

  STNode* curr;
  for(curr = this->child; curr != 0; curr = curr->sibling) { curr->parent = this->parent; }
  if(this == this->parent->child) { this->parent->child = this->child; }
  else
  {
    for(curr = this->parent->child; curr->sibling != this; curr = curr->sibling);
    curr->sibling = this->child;
  }
  for(curr = this->child; curr->sibling != 0; curr = curr->sibling);
  curr->sibling = this->sibling;

  this->parent = this->child = this->sibling = 0;
}

// Assembly:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x11805
movq 0x10(%rdi), %rdx
testq %rdx, %rdx
je 0x11805
leaq 0x10(%rdi), %rcx
movq %rax, %rsi
movq %rdx, 0x10(%rsi)
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
jne 0x117b3
movq 0x18(%rdx), %rsi
cmpq %rdi, %rsi
je 0x117db
movq %rsi, %rdx
movq 0x20(%rsi), %rsi
cmpq %rdi, %rsi
jne 0x117c9
movq %rax, 0x20(%rdx)
jmp 0x117e3
movq %rax, 0x18(%rdx)
movq 0x18(%rdi), %rax
movq %rax, %rdx
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0x117e3
movq 0x20(%rdi), %rax
movq %rax, 0x20(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::STNode::determineSize(unsigned int&, unsigned int&)
void
STNode::determineSize(uint& nodes, uint& leaves)
{
  nodes++;
  if(this->child == 0) { leaves++; }
  else { this->child->determineSize(nodes, leaves); }
  if(this->sibling != 0) { this->sibling->determineSize(nodes, leaves); }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
incl (%r14)
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x1182d
movq %r14, %rsi
movq %rbx, %rdx
callq 0x11806
jmp 0x1182f
incl (%rbx)
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0x11814
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::STNode::computeStoredDocuments(unsigned int*)
void
STNode::computeStoredDocuments(usint* documents)
{
  this->stored_documents = 0;
  delete this->docs; this->docs = 0;
  if(this->child == 0)
  {
    this->docs = new std::vector<uint>(documents + this->range.first, documents + this->range.second + 1);
  }
  else
  {
    this->docs = new std::vector<uint>;
    for(STNode* curr = this->child; curr != 0; curr = curr->sibling)
    {
      this->docs->insert(this->docs->end(), curr->docs->begin(), curr->docs->end());
      this->stored_documents += curr->stored_documents;
    }
  }
  removeDuplicates(this->docs, (this->docs->size() >= 65536));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl $0x0, 0x30(%rdi)
movq 0x40(%rdi), %r14
testq %r14, %r14
je 0x11870
movq (%r14), %rdi
testq %rdi, %rdi
je 0x11870
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x3270
movl $0x18, %esi
movq %r14, %rdi
callq 0x3270
movq $0x0, 0x40(%rbx)
movq 0x18(%rbx), %r12
movl $0x18, %edi
callq 0x3260
movq %rax, %r14
testq %r12, %r12
je 0x118df
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %r14, 0x40(%rbx)
movq 0x40(%rbx), %rdi
movq 0x8(%rdi), %rsi
movq 0x40(%r12), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0x14fac
movl 0x30(%r12), %eax
addl %eax, 0x30(%rbx)
movq 0x20(%r12), %r12
testq %r12, %r12
jne 0x118ae
movq 0x40(%rbx), %r14
jmp 0x11902
movl 0x4(%rbx), %eax
movl 0x8(%rbx), %ecx
leaq (%r15,%rax,4), %rsi
leaq (%r15,%rcx,4), %rdx
addq $0x4, %rdx
leaq 0x7(%rsp), %rcx
movq %r14, %rdi
callq 0x146a8
movq %r14, 0x40(%rbx)
movq 0x8(%r14), %rax
subq (%r14), %rax
xorl %esi, %esi
cmpq $0x3fffd, %rax          # imm = 0x3FFFD
setae %sil
movq %r14, %rdi
callq 0xb7c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r14, %rdi
callq 0x3270
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::STNode::containsAllDocuments()
void
STNode::containsAllDocuments()
{
  if(this->docs != 0)
  {
    this->stored_documents = this->docs->size();
    delete this->docs; this->docs = 0;
  }
  for(STNode* curr = this; curr != 0; curr = curr->parent)
  {
    curr->contains_all = true;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
testq %r14, %r14
je 0x11989
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
shrq $0x2, %rax
movl %eax, 0x30(%rbx)
testq %rdi, %rdi
je 0x11974
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x3270
movl $0x18, %esi
movq %r14, %rdi
callq 0x3270
movq $0x0, 0x40(%rbx)
movb $0x1, 0x38(%rbx)
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x11989
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::DocArray::~DocArray()
DocArray::~DocArray()
{
  delete this->leaf_ranges; this->leaf_ranges = 0;
  delete this->first_children; this->first_children = 0;
  delete this->parents; this->parents = 0;
  delete this->next_leaves; this->next_leaves = 0;

  delete this->rule_borders; this->rule_borders = 0;
  delete this->rules; this->rules = 0;

  delete this->block_borders; this->block_borders = 0;
  delete this->blocks; this->blocks = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x12666
movq %r14, %rdi
callq 0x186fe
movl $0x48, %esi
movq %r14, %rdi
callq 0x3270
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x1268c
movq %r14, %rdi
callq 0x1aafa
movl $0x48, %esi
movq %r14, %rdi
callq 0x3270
movq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x126b2
movq %r14, %rdi
callq 0x16f06
movl $0x28, %esi
movq %r14, %rdi
callq 0x3270
movq $0x0, 0x18(%rbx)
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x126d8
movq %r14, %rdi
callq 0x16f06
movl $0x28, %esi
movq %r14, %rdi
callq 0x3270
movq $0x0, 0x20(%rbx)
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x126fe
movq %r14, %rdi
callq 0x1aafa
movl $0x48, %esi
movq %r14, %rdi
callq 0x3270
movq $0x0, 0x28(%rbx)
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x12724
movq %r14, %rdi
callq 0x16f06
movl $0x28, %esi
movq %r14, %rdi
callq 0x3270
movq $0x0, 0x30(%rbx)
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x1274a
movq %r14, %rdi
callq 0x1aafa
movl $0x48, %esi
movq %r14, %rdi
callq 0x3270
movq $0x0, 0x38(%rbx)
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x12770
movq %r14, %rdi
callq 0x16f06
movl $0x28, %esi
movq %r14, %rdi
callq 0x3270
movq $0x0, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::parseLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<unsigned int, std::allocator<unsigned int>>&, int, std::vector<unsigned int, std::allocator<unsigned int>>&)
void
parseLine(std::string& row, std::vector<usint>& before, int separator, std::vector<usint>& after)
{
  bool found = false, num = false;
  usint value = 0;
  for(usint i = 0; i < row.length(); i++)
  {
    if(isdigit(row[i])) { value = 10 * value + row[i] - '0'; num = true; }
    else if(num)
    {
      if(found) { after.push_back(value); }
      else      { before.push_back(value); }
      value = 0; num = false;
    }
    if(row[i] == separator) { found = true; }
  }
  if(num)
  {
    if(found) { after.push_back(value); }
    else      { before.push_back(value); }
    value = 0; num = false;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x0, 0x4(%rsp)
movq 0x8(%rdi), %r8
testq %r8, %r8
je 0x128c7
movl %edx, %ebp
movq %rsi, %r9
movq %rdi, %r15
movq (%rdi), %rdx
xorl %eax, %eax
movl $0x1, %r13d
movl $0x1, %r12d
xorl %r14d, %r14d
xorl %esi, %esi
xorl %ebx, %ebx
movq %rcx, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movsbl (%rdx,%r14), %edi
addl $-0x30, %edi
cmpl $0x9, %edi
ja 0x127f6
leal (%rax,%rax,4), %eax
leal (%rdi,%rax,2), %eax
movl %eax, 0x4(%rsp)
movb $0x1, %sil
jmp 0x1285c
testb $0x1, %sil
je 0x1285c
testb $0x1, %bl
je 0x12817
movq 0x8(%rcx), %rsi
cmpq 0x10(%rcx), %rsi
je 0x1282d
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rcx)
jmp 0x12849
movq 0x8(%r9), %rsi
cmpq 0x10(%r9), %rsi
je 0x12832
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r9)
jmp 0x12849
movq %rcx, %rdi
jmp 0x12835
movq %r9, %rdi
leaq 0x4(%rsp), %rdx
callq 0xbe04
movq 0x8(%rsp), %r9
movq 0x10(%rsp), %rcx
movl $0x0, 0x4(%rsp)
movq (%r15), %rdx
movq 0x8(%r15), %r8
xorl %eax, %eax
xorl %esi, %esi
movsbl (%rdx,%r14), %edi
cmpl %ebp, %edi
movzbl %bl, %ebx
cmovel %r13d, %ebx
movl %r12d, %r14d
incl %r12d
cmpq %r14, %r8
ja 0x127da
testb $0x1, %sil
je 0x128c7
testb $0x1, %bl
je 0x1289a
movq 0x8(%rcx), %rsi
cmpq 0x10(%rcx), %rsi
je 0x128b0
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rcx)
jmp 0x128c7
movq 0x8(%r9), %rsi
cmpq 0x10(%r9), %rsi
je 0x128ba
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r9)
jmp 0x128c7
leaq 0x4(%rsp), %rdx
movq %rcx, %rdi
jmp 0x128c2
leaq 0x4(%rsp), %rdx
movq %r9, %rdi
callq 0xbe04
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::DocArray::writeTo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
void
DocArray::writeTo(const std::string& base_name) const
{
  std::string output_name = base_name + DOCUMENT_EXTENSION;
  std::ofstream output(output_name.c_str(), std::ios_base::binary);
  if(!output)
  {
    std::cerr << "DocArray: Error creating output file " << output_name << "!" << std::endl;
    return;
  }

  usint flags = 0; if(this->usesRLE()) { flags |= RLE_FLAG; }
  output.write((char*)(&flags), sizeof(flags));

  this->leaf_ranges->writeTo(output);
  this->first_children->writeTo(output);
  this->parents->writeBuffer(output);
  this->next_leaves->writeBuffer(output);

  if(this->hasGrammar())
  {
    this->rule_borders->writeTo(output);
    this->rules->writeBuffer(output);
    this->block_borders->writeTo(output);
    this->blocks->writeBuffer(output);
  }

  output.close();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
leaq 0x147f0(%rip), %rdx     # 0x288c8
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xb43d
movq (%r14), %rsi
leaq 0x28(%rsp), %rdi
movl $0x4, %edx
callq 0x32a0
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
je 0x14178
movq 0x13ee2(%rip), %rdi     # 0x27ff0
leaq 0xa9ef(%rip), %rsi      # 0x1eb04
movl $0x25, %edx
callq 0x32b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x13ec0(%rip), %rdi     # 0x27ff0
callq 0x32b0
movq %rax, %rbx
leaq 0xa779(%rip), %rsi      # 0x1e8b8
movl $0x1, %edx
movq %rax, %rdi
callq 0x32b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
jmp 0x14212
movzbl 0x4a(%rbx), %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x28(%rsp), %rdi
movl $0x4, %edx
callq 0x3300
movq 0x8(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x17de6
movq 0x10(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1ab00
movq 0x18(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x16f20
movq 0x20(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x16f20
cmpb $0x1, 0x49(%rbx)
jne 0x14208
movq 0x28(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1ab00
movq 0x30(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x16f20
movq 0x38(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1ab00
movq 0x40(%rbx), %rdi
leaq 0x28(%rsp), %rsi
callq 0x16f20
leaq 0x28(%rsp), %rdi
callq 0x3330
movq 0x13da7(%rip), %rax     # 0x27fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x28(%rsp,%rcx)
callq 0x3210
leaq 0x120(%rsp), %rdi
callq 0x30d0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1425f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x1427e
jmp 0x14271
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3350
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14299
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3270
movq %rbx, %rdi
callq 0x3460
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::DocArray::listDocuments(std::pair<unsigned int, unsigned int>) const
std::vector<usint>*
DocArray::listDocuments(pair_type range) const
{
  if(isEmpty(range) || range.second >= this->getSize()) { return 0; }

  std::vector<usint>* result = this->documentListing<usint>(range);
  if(result != 0) { removeDuplicates(result, false); }

  return result;
}

// Assembly:
pushq %rbx
movq %rsi, %rax
shrq $0x20, %rax
cmpl %eax, %esi
ja 0x14595
movq (%rdi), %rcx
cmpl %eax, 0x4(%rcx)
jbe 0x14595
callq 0x147b0
testq %rax, %rax
je 0x14595
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0xb7c0
jmp 0x14597
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::DocArray::listDocumentsRLE(std::pair<unsigned int, unsigned int>) const
std::vector<pair_type>*
DocArray::listDocumentsRLE(pair_type range) const
{
  if(isEmpty(range) || range.second >= this->getSize()) { return 0; }

  std::vector<pair_type>* result = this->documentListing<pair_type>(range);
  if(result != 0) { mergeRanges(result, false); }

  return result;
}

// Assembly:
pushq %rbx
movq %rsi, %rax
shrq $0x20, %rax
cmpl %eax, %esi
ja 0x145e1
movq (%rdi), %rcx
cmpl %eax, 0x4(%rcx)
jbe 0x145e1
callq 0x14aea
testq %rax, %rax
je 0x145e1
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1cb08
jmp 0x145e3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::DocArray::directListing(std::pair<unsigned int, unsigned int>) const
std::vector<usint>*
DocArray::directListing(pair_type range) const
{
  if(isEmpty(range) || range.second >= this->getSize()) { return 0; }
  std::vector<usint>* result = new std::vector<usint>;
  this->processRange(range, *result);
  removeDuplicates(result, false);
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rsi, %rax
shrq $0x20, %rax
cmpl %eax, %r14d
ja 0x1463c
movq %rdi, %r15
movq (%rdi), %rcx
cmpl %eax, 0x4(%rcx)
jbe 0x1463c
movl $0x18, %edi
callq 0x3260
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x14e24
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb7c0
jmp 0x1463e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/docarray.cpp
// Function: CSA::DocArray::directListingRLE(std::pair<unsigned int, unsigned int>) const
std::vector<pair_type>*
DocArray::directListingRLE(pair_type range) const
{
  if(isEmpty(range) || range.second >= this->getSize()) { return 0; }
  std::vector<pair_type>* result = new std::vector<pair_type>;
  this->processRange(range, *result);
  mergeRanges(result, false);
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rsi, %rax
shrq $0x20, %rax
cmpl %eax, %r14d
ja 0x1469c
movq %rdi, %r15
movq (%rdi), %rcx
cmpl %eax, 0x4(%rcx)
jbe 0x1469c
movl $0x18, %edi
callq 0x3260
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x14eb2
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1cb08
jmp 0x1469e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/./docarray.h
// Function: void CSA::DocArray::processRange<unsigned int>(std::pair<unsigned int, unsigned int>, std::vector<unsigned int, std::allocator<unsigned int>>&) const
void
    processRange(pair_type range, std::vector<T>& result) const
    {
      if(isEmpty(range)) { return; }

      usint* res = this->rlcsa.locate(range);
      this->rlcsa.getSequenceForPosition(res, length(range));
      for(usint i = 0; i < length(range); i++)
      {
        this->addItem(res[i], result);
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r12
shrq $0x20, %r12
subl %esi, %r12d
jb 0x14ea3
movq %rdx, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x8782
movq %rax, %r14
movq (%r15), %rdi
leal 0x1(%r12), %edx
movq %rax, %rsi
callq 0x9b48
incl %r12d
je 0x14ea3
movl %r12d, %r12d
xorl %r13d, %r13d
leaq 0xc(%rsp), %r15
movl (%r14,%r13,4), %eax
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x14e90
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x14e9b
movq %rbx, %rdi
movq %r15, %rdx
callq 0xbe04
incq %r13
cmpq %r13, %r12
jne 0x14e72
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/adamnovak[P]rlcsa/bits/succinctvector.cpp
// Function: CSA::SuccinctVector::SuccinctVector(std::basic_ifstream<char, std::char_traits<char>>&)
SuccinctVector::SuccinctVector(std::ifstream& file) :
  BitVector()
{
  this->readHeader(file);
  this->readArray(file);

  this->integer_bits = length(this->size);
  this->indexForRank();
  this->indexForSelect();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x17d5c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1727e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x172d6
movl (%rbx), %eax
bsrl %eax, %ecx
xorl $-0x20, %ecx
addl $0x21, %ecx
testl %eax, %eax
cmovel %eax, %ecx
movl %ecx, 0x20(%rbx)
movq %rbx, %rdi
callq 0x1a504
movq %rbx, %rdi
callq 0x1a676
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x17d70
movq %r14, %rdi
callq 0x3460
nop