LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::drawMainMenu()
void DNWindow::drawMainMenu()
{
    drawHeader();
    drawMenu();
    drawOptions();
    drawCommandLine();
    string input = "";
    drawCommandLine();
    inputString(input);
    executeMenuOption(input);


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x9b30
movq -0x70(%rbp), %rdi
callq 0xa2e0
movq -0x70(%rbp), %rdi
callq 0x9f90
movq -0x70(%rbp), %rdi
callq 0xa3a0
leaq -0x29(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x35e0
movq -0x68(%rbp), %rdx
leaq 0x2adf(%rip), %rsi      # 0xc55b
leaq -0x28(%rbp), %rdi
callq 0x42f0
jmp 0x9a87
leaq -0x29(%rbp), %rdi
callq 0x3400
movq -0x70(%rbp), %rdi
callq 0xa3a0
jmp 0x9a9b
movq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa7b0
jmp 0x9aaa
leaq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3190
jmp 0x9ab9
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xa900
jmp 0x9ac8
leaq -0x60(%rbp), %rdi
callq 0x3200
leaq -0x28(%rbp), %rdi
callq 0x3200
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x3400
jmp 0x9b23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x9b1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3200
leaq -0x28(%rbp), %rdi
callq 0x3200
movq -0x38(%rbp), %rdi
callq 0x35d0
nopl (%rax)
// File: syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::drawHeader()
void DNWindow::drawHeader()
{
    struct winsize w;
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
    for (int i = 0; i < w.ws_col; i++) {
        if (i == 0) {
            addch(ACS_ULCORNER);
            continue;
        }
        if (i == w.ws_col - 1) {
            addch(ACS_URCORNER);
            continue;
        }
        addch(ACS_HLINE);
    }
    addch(ACS_VLINE);
    printw("TicTacToe\n");
    move(1, w.ws_col - 1);
    addch(ACS_VLINE);
    for (int i = 0; i < w.ws_col; i++) {
        if (i == 0) {
            addch(ACS_LLCORNER);
            continue;
        }
        if (i == w.ws_col - 1) {
            addch(ACS_LRCORNER);
            continue;
        }
        addch(ACS_HLINE);
    }
    refreshDN();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x34f0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movzwl -0xe(%rbp), %ecx
cmpl %ecx, %eax
jge 0x9be5
cmpl $0x0, -0x14(%rbp)
jne 0x9b8f
movq 0x7458(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movq 0x7426(%rip), %rax      # 0x10fa8
movl 0x1b0(%rax), %esi
callq 0x3100
jmp 0x9bd7
movl -0x14(%rbp), %eax
movzwl -0xe(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x9bbb
movq 0x742c(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movq 0x73fa(%rip), %rax      # 0x10fa8
movl 0x1ac(%rax), %esi
callq 0x3100
jmp 0x9bd7
movq 0x740e(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movq 0x73dc(%rip), %rax      # 0x10fa8
movl 0x1c4(%rax), %esi
callq 0x3100
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9b60
movq 0x73e4(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movq 0x73b2(%rip), %rax      # 0x10fa8
movl 0x1e0(%rax), %esi
callq 0x3100
leaq 0x2898(%rip), %rdi      # 0xc4a0
movb $0x0, %al
callq 0x3380
movzwl -0xe(%rbp), %esi
subl $0x1, %esi
movl $0x1, %edi
callq 0x3260
movq 0x73a9(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movq 0x7377(%rip), %rax      # 0x10fa8
movl 0x1e0(%rax), %esi
callq 0x3100
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movzwl -0xe(%rbp), %ecx
cmpl %ecx, %eax
jge 0x9cc8
cmpl $0x0, -0x18(%rbp)
jne 0x9c72
movq 0x7375(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movq 0x7343(%rip), %rax      # 0x10fa8
movl 0x1b4(%rax), %esi
callq 0x3100
jmp 0x9cba
movl -0x18(%rbp), %eax
movzwl -0xe(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x9c9e
movq 0x7349(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movq 0x7317(%rip), %rax      # 0x10fa8
movl 0x1a8(%rax), %esi
callq 0x3100
jmp 0x9cba
movq 0x732b(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movq 0x72f9(%rip), %rax      # 0x10fa8
movl 0x1c4(%rax), %esi
callq 0x3100
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9c43
movq -0x20(%rbp), %rdi
callq 0x9ce0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::drawMenu()
void DNWindow::drawMenu()
{
    struct winsize w;
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
    move(w.ws_row + 3, w.ws_col);
    middleString(string("Please select one of these following options:"), 3);


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
xorl %eax, %eax
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0x10(%rbp), %rdx
callq 0x34f0
movzwl -0x10(%rbp), %edi
addl $0x3, %edi
movzwl -0xe(%rbp), %esi
callq 0x3260
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x35e0
movq -0x50(%rbp), %rdx
leaq 0x21da(%rip), %rsi      # 0xc50b
leaq -0x30(%rbp), %rdi
callq 0x42f0
jmp 0xa33c
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x3, %edx
callq 0xa260
jmp 0xa350
leaq -0x30(%rbp), %rdi
callq 0x3200
leaq -0x31(%rbp), %rdi
callq 0x3400
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa38b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3200
leaq -0x31(%rbp), %rdi
callq 0x3400
movq -0x40(%rbp), %rdi
callq 0x35d0
nopl (%rax)
// File: syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::drawCommandLine()
void DNWindow::drawCommandLine()
{
    struct winsize w;
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
    start_color();
    init_pair(1, COLOR_RED, COLOR_BLACK);
    attron(COLOR_PAIR(1));
    mvprintw(w.ws_row - 1, 0, "COMMAND> ");
    move(w.ws_col - 1, 10);
    attron(COLOR_PAIR(0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x34f0
callq 0x30b0
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x3070
movq 0x6bf5(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
movl %eax, %edx
callq 0x31c0
movzwl -0x10(%rbp), %edi
subl $0x1, %edi
xorl %esi, %esi
leaq 0x213d(%rip), %rdx      # 0xc539
movb $0x0, %al
callq 0x34d0
movzwl -0xe(%rbp), %edi
subl $0x1, %edi
movl $0xa, %esi
callq 0x3260
movq 0x6bb5(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x31c0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::moveUp()
void DNWindow::moveUp()
{
    int y, x;
    getsyx(y, x);
    move(y - 1, x);
    refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x6b85(%rip), %rax      # 0x10fc8
cmpq $0x0, (%rax)
je 0xa4f4
xorl %eax, %eax
movq 0x6b72(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xa472
movq 0x6b66(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movb 0x1a(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
jmp 0xa479
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0xa479
movl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0xa491
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0xa4f2
xorl %eax, %eax
movq 0x6b2e(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xa4b1
movq 0x6b22(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movswl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0xa4bb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0xa4bb
movl -0x18(%rbp), %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
movq 0x6afe(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xa4e2
movq 0x6af2(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0xa4ec
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x1c(%rbp)
jmp 0xa4ec
movl -0x1c(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xa4f4
jmp 0xa4f6
movl -0xc(%rbp), %edi
subl $0x1, %edi
movl -0x10(%rbp), %esi
callq 0x3260
callq 0x35a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::moveDown()
void DNWindow::moveDown()
{
    int y, x;
    getsyx(y, x);
    move(y + 1, x);
    refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x6aa5(%rip), %rax      # 0x10fc8
cmpq $0x0, (%rax)
je 0xa5d4
xorl %eax, %eax
movq 0x6a92(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xa552
movq 0x6a86(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movb 0x1a(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
jmp 0xa559
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0xa559
movl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0xa571
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0xa5d2
xorl %eax, %eax
movq 0x6a4e(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xa591
movq 0x6a42(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movswl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0xa59b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0xa59b
movl -0x18(%rbp), %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
movq 0x6a1e(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xa5c2
movq 0x6a12(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0xa5cc
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x1c(%rbp)
jmp 0xa5cc
movl -0x1c(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xa5d4
jmp 0xa5d6
movl -0xc(%rbp), %edi
addl $0x1, %edi
movl -0x10(%rbp), %esi
callq 0x3260
callq 0x35a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::moveLeft()
void DNWindow::moveLeft()
{
    int y, x;
    getsyx(y, x);
    move(y, x - 1);
    refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x69c5(%rip), %rax      # 0x10fc8
cmpq $0x0, (%rax)
je 0xa6b4
xorl %eax, %eax
movq 0x69b2(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xa632
movq 0x69a6(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movb 0x1a(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
jmp 0xa639
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0xa639
movl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0xa651
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0xa6b2
xorl %eax, %eax
movq 0x696e(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xa671
movq 0x6962(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movswl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0xa67b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0xa67b
movl -0x18(%rbp), %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
movq 0x693e(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xa6a2
movq 0x6932(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0xa6ac
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x1c(%rbp)
jmp 0xa6ac
movl -0x1c(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xa6b4
jmp 0xa6b6
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
subl $0x1, %esi
callq 0x3260
callq 0x35a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::moveRight()
void DNWindow::moveRight()
{
    int y, x;
    getsyx(y, x);
    move(y, x + 1);
    refresh();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x68e5(%rip), %rax      # 0x10fc8
cmpq $0x0, (%rax)
je 0xa794
xorl %eax, %eax
movq 0x68d2(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xa712
movq 0x68c6(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movb 0x1a(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
jmp 0xa719
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0xa719
movl -0x14(%rbp), %eax
cmpl $0x0, %eax
je 0xa731
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0xa792
xorl %eax, %eax
movq 0x688e(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xa751
movq 0x6882(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movswl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0xa75b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0xa75b
movl -0x18(%rbp), %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
movq 0x685e(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xa782
movq 0x6852(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0xa78c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x1c(%rbp)
jmp 0xa78c
movl -0x1c(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xa794
jmp 0xa796
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
addl $0x1, %esi
callq 0x3260
callq 0x35a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: syky27[P]TicTacToe/src/DNWindow.cpp
// Function: DNWindow::inputString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void DNWindow::inputString(string& input)
{
    
    refreshDN();

    char ch;
    int key;
    allowMacDev();

    while ((key = getch())) {
        ch = key;
        DNLogService::sharedObject().log(ch);

        if (key == KEY_BACKSPACE && input.size() > 0) {
            input = input.substr(0, input.size() - 1);
            moveLeft();
            addch(' ');
            refreshDN();
            moveLeft();
            refreshDN();
            continue;
        }
        else if (key == KEY_BACKSPACE) {
            sound();
            continue;
        }
        if (key == '\n') {
            break;
        }
        input += ch;
        addch(ch);
        moveRight();
        refreshDN();

    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x9ce0
movq -0x40(%rbp), %rdi
callq 0xb9a0
movq 0x67f3(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
callq 0x3150
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0xa8fa
movl -0x18(%rbp), %eax
movb %al, -0x11(%rbp)
callq 0x43c0
movq %rax, %rdi
movsbl -0x11(%rbp), %esi
callq 0x5480
cmpl $0x107, -0x18(%rbp)     # imm = 0x107
jne 0xa8a0
movq -0x10(%rbp), %rdi
callq 0x3250
cmpq $0x0, %rax
jbe 0xa8a0
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3250
movq -0x48(%rbp), %rsi
movq %rax, %rcx
subq $0x1, %rcx
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x33b0
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x34a0
leaq -0x38(%rbp), %rdi
callq 0x3200
movq -0x40(%rbp), %rdi
callq 0xa5f0
movq 0x675d(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movl $0x20, %esi
callq 0x3100
movq -0x40(%rbp), %rdi
callq 0x9ce0
movq -0x40(%rbp), %rdi
callq 0xa5f0
movq -0x40(%rbp), %rdi
callq 0x9ce0
jmp 0xa7d6
cmpl $0x107, -0x18(%rbp)     # imm = 0x107
jne 0xa8b7
movq -0x40(%rbp), %rdi
callq 0xbe60
jmp 0xa7d6
jmp 0xa8b9
cmpl $0xa, -0x18(%rbp)
jne 0xa8c1
jmp 0xa8fa
movb -0x11(%rbp), %al
movq -0x10(%rbp), %rdi
movsbl %al, %esi
callq 0x3210
movq 0x66f9(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movsbl -0x11(%rbp), %esi
callq 0x3100
movq -0x40(%rbp), %rdi
callq 0xa6d0
movq -0x40(%rbp), %rdi
callq 0x9ce0
jmp 0xa7d6
addq $0x50, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xaf40
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x35e0
movq -0x68(%rbp), %rdx
leaq 0x1774(%rip), %rsi      # 0xc57e
leaq -0x38(%rbp), %rdi
callq 0x42f0
jmp 0xae15
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9d00
jmp 0xae24
leaq -0x38(%rbp), %rdi
callq 0x3200
leaq -0x39(%rbp), %rdi
callq 0x3400
movq -0x70(%rbp), %rdi
callq 0x9b30
movq -0x70(%rbp), %rdi
callq 0x9ce0
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0x54(%rbp), %rdx
movb $0x0, %al
callq 0x34f0
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x3260
movl $0x0, -0x58(%rbp)
movl -0x58(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xaf15
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0xaf05
movq 0x613b(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl -0x58(%rbp), %esi
movl -0x10(%rbp), %edx
addl -0x5c(%rbp), %edx
callq 0x33c0
cmpl $-0x1, %eax
jne 0xaeb0
jmp 0xaecc
movq 0x6119(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movq 0x60e7(%rip), %rax      # 0x10fa8
movl 0x184(%rax), %esi
callq 0x3100
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0xae82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xaefa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3200
leaq -0x39(%rbp), %rdi
callq 0x3400
jmp 0xaf2d
jmp 0xaf07
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0xae6f
movq -0x70(%rbp), %rdi
callq 0x9ce0
movq -0x70(%rbp), %rdi
callq 0xb0a0
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x35d0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x43c0
movq %rax, %rdi
leaq 0x1165(%rip), %rsi      # 0xc10b
callq 0x5520
movq -0x80(%rbp), %rsi
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3190
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x56c0
movq %rax, -0x68(%rbp)
jmp 0xafd3
movq -0x68(%rbp), %rdi
leaq 0x157c(%rip), %rsi      # 0xc55a
callq 0x5520
jmp 0xafe5
leaq -0x30(%rbp), %rdi
callq 0x3200
callq 0x3a90
movq %rax, %rdi
callq 0xaf40
callq 0x3a90
movq -0x80(%rbp), %rsi
movq %rax, -0x90(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3190
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movl $0xd, %edx
callq 0xa260
jmp 0xb035
leaq -0x60(%rbp), %rdi
callq 0x3200
callq 0x3a90
movq %rax, %rdi
callq 0x9ce0
movl $0x3, %edi
callq 0x32a0
callq 0x3a90
movq %rax, %rdi
callq 0xaf60
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3200
jmp 0xb097
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3200
movq -0x38(%rbp), %rdi
callq 0x35d0
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
xorl %eax, %eax
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0x18(%rbp), %rdx
callq 0x34f0
movq -0x88(%rbp), %rdi
callq 0xaf40
movq -0x88(%rbp), %rdi
callq 0x9b30
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x35e0
movq -0x80(%rbp), %rdx
leaq 0x116c(%rip), %rsi      # 0xc60f
leaq -0x38(%rbp), %rdi
callq 0x42f0
jmp 0xb4ae
movq -0x88(%rbp), %rdi
movzwl -0x18(%rbp), %edx
shrl %edx
leaq -0x38(%rbp), %rsi
callq 0xa260
jmp 0xb4c6
leaq -0x38(%rbp), %rdi
callq 0x3200
leaq -0x39(%rbp), %rdi
callq 0x3400
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa7b0
movq -0x10(%rbp), %rdi
callq 0x3540
cmpq $0x0, %rax
jne 0xb5ac
leaq -0x71(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x35e0
movq -0x90(%rbp), %rdx
leaq 0x10af(%rip), %rsi      # 0xc5c8
leaq -0x70(%rbp), %rdi
callq 0x42f0
jmp 0xb524
movq -0x88(%rbp), %rdi
movzwl -0x18(%rbp), %edx
shrl %edx
leaq -0x70(%rbp), %rsi
callq 0xa260
jmp 0xb53c
leaq -0x70(%rbp), %rdi
callq 0x3200
leaq -0x71(%rbp), %rdi
callq 0x3400
jmp 0xb5ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xb573
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3200
leaq -0x39(%rbp), %rdi
callq 0x3400
jmp 0xb5d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xb5a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3200
leaq -0x71(%rbp), %rdi
callq 0x3400
jmp 0xb5d8
jmp 0xb5b3
jmp 0xb4d8
movq -0x88(%rbp), %rdi
callq 0xaf40
movq -0x88(%rbp), %rdi
callq 0x9b30
movb $0x1, %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x35d0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x34e0
movq -0x48(%rbp), %rdi
callq 0xaf40
jmp 0xb64c
movq -0x48(%rbp), %rdi
callq 0x9b30
jmp 0xb657
movq -0x48(%rbp), %rdi
callq 0xb6b0
jmp 0xb662
movq -0x48(%rbp), %rdi
callq 0x9ce0
jmp 0xb66d
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb860
movl %eax, -0x4c(%rbp)
jmp 0xb67f
leaq -0x30(%rbp), %rdi
callq 0x3200
movl -0x4c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3200
movq -0x38(%rbp), %rdi
callq 0x35d0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x35a0
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x34f0
callq 0x30b0
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x3070
movzwl -0x10(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %edi
movzwl -0xe(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %esi
leaq 0xf27(%rip), %rdx       # 0xc633
movb $0x0, %al
callq 0x34d0
movzwl -0x10(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %edi
addl $0x1, %edi
movzwl -0xe(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %esi
leaq 0xf0e(%rip), %rdx       # 0xc647
movb $0x0, %al
callq 0x34d0
movzwl -0x10(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %edi
addl $0x6, %edi
movzwl -0xe(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %esi
leaq 0xd99(%rip), %rdx       # 0xc4ff
movb $0x0, %al
callq 0x34d0
movq 0x585c(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movzwl -0x10(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %esi
movzwl -0xe(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %edx
addl $0x1, %edx
callq 0x33c0
cmpl $-0x1, %eax
jne 0xb7a2
jmp 0xb7b6
movq 0x5827(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movl $0x31, %esi
callq 0x3100
movq 0x5813(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movzwl -0x10(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %esi
addl $0x1, %esi
movzwl -0xe(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %edx
addl $0x1, %edx
callq 0x33c0
cmpl $-0x1, %eax
jne 0xb7ee
jmp 0xb802
movq 0x57db(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movl $0x32, %esi
callq 0x3100
movq 0x57c7(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movzwl -0x10(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %esi
addl $0x6, %esi
movzwl -0xe(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %edx
addl $0x1, %edx
callq 0x33c0
cmpl $-0x1, %eax
jne 0xb83a
jmp 0xb84e
movq 0x578f(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movl $0x51, %esi
callq 0x3100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xa3a0
movq -0x58(%rbp), %rdi
callq 0x9ce0
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa7b0
movq -0x18(%rbp), %rdi
callq 0x3180
movq %rax, %rdi
callq 0x3560
cmpl $0x1, %eax
je 0xb8bf
movq -0x18(%rbp), %rdi
callq 0x3180
movq %rax, %rdi
callq 0x3560
cmpl $0x2, %eax
jne 0xb8d8
movq -0x18(%rbp), %rdi
callq 0x3180
movq %rax, %rdi
callq 0x3560
movl %eax, -0x4(%rbp)
jmp 0xb98a
movq -0x18(%rbp), %rdi
leaq 0xc8b(%rip), %rsi       # 0xc56e
callq 0x80c0
testb $0x1, %al
jne 0xb902
movq -0x18(%rbp), %rdi
leaq 0xc79(%rip), %rsi       # 0xc570
callq 0x80c0
testb $0x1, %al
jne 0xb902
jmp 0xb90d
movq -0x58(%rbp), %rdi
callq 0xaf60
jmp 0xb981
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x35e0
movq -0x60(%rbp), %rdx
leaq 0xd34(%rip), %rsi       # 0xc659
leaq -0x38(%rbp), %rdi
callq 0x42f0
jmp 0xb930
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xaf80
jmp 0xb93f
leaq -0x38(%rbp), %rdi
callq 0x3200
leaq -0x39(%rbp), %rdi
callq 0x3400
jmp 0xb981
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xb976
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3200
leaq -0x39(%rbp), %rdi
callq 0x3400
jmp 0xb993
jmp 0xb983
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x35d0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0xbb30
movq 0x54f4(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rax
movl (%rax), %edx
callq 0x33c0
cmpl $-0x1, %eax
jne 0xbaf7
jmp 0xbb0b
movq 0x54d2(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movl $0x58, %esi
callq 0x3100
callq 0x30a0
movq -0x60(%rbp), %rdi
callq 0xa6d0
movq -0x60(%rbp), %rdi
callq 0xa5f0
movq -0x60(%rbp), %rdi
callq 0x9ce0
jmp 0xbc04
cmpl $0x1, -0xc(%rbp)
jne 0xbb8e
movq 0x5493(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rax
movl (%rax), %edx
callq 0x33c0
cmpl $-0x1, %eax
jne 0xbb58
jmp 0xbb6c
movq 0x5471(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movl $0x4f, %esi
callq 0x3100
callq 0x30a0
movq -0x60(%rbp), %rdi
callq 0xa6d0
movq -0x60(%rbp), %rdi
callq 0xa5f0
movq -0x60(%rbp), %rdi
callq 0x9ce0
jmp 0xbc02
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x35e0
movq -0x68(%rbp), %rdx
leaq 0xabf(%rip), %rsi       # 0xc665
leaq -0x40(%rbp), %rdi
callq 0x42f0
jmp 0xbbb1
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xaf80
jmp 0xbbc0
leaq -0x40(%rbp), %rdi
callq 0x3200
leaq -0x41(%rbp), %rdi
callq 0x3400
jmp 0xbc02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xbbf7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3200
leaq -0x41(%rbp), %rdi
callq 0x3400
jmp 0xbc0a
jmp 0xbc04
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x35d0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x537f(%rip), %rax      # 0x10fc8
cmpq $0x0, (%rax)
je 0xbd06
xorl %eax, %eax
movq 0x536c(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xbc78
movq 0x5360(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movb 0x1a(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x64(%rbp)
jmp 0xbc7f
xorl %eax, %eax
movl %eax, -0x64(%rbp)
jmp 0xbc7f
movl -0x64(%rbp), %eax
cmpl $0x0, %eax
je 0xbc9d
movq -0x18(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0xbd04
xorl %eax, %eax
movq 0x5322(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xbcbd
movq 0x5316(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movswl (%rax), %eax
movl %eax, -0x68(%rbp)
jmp 0xbcc7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x68(%rbp)
jmp 0xbcc7
movl -0x68(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
movq 0x52ef(%rip), %rcx      # 0x10fc8
cmpq (%rcx), %rax
je 0xbcf1
movq 0x52e3(%rip), %rax      # 0x10fc8
movq (%rax), %rax
movswl 0x2(%rax), %eax
movl %eax, -0x6c(%rbp)
jmp 0xbcfb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x6c(%rbp)
jmp 0xbcfb
movl -0x6c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0xbd06
jmp 0xbd08
cmpl $0x2, -0xc(%rbp)
jne 0xbd3e
movq 0x52bb(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movl $0x58, %esi
callq 0x3100
callq 0x30a0
movq -0x60(%rbp), %rdi
callq 0xa6d0
movq -0x60(%rbp), %rdi
callq 0xa5f0
jmp 0xbde7
cmpl $0x1, -0xc(%rbp)
jne 0xbd71
movq 0x5285(%rip), %rax      # 0x10fd0
movq (%rax), %rdi
movl $0x4f, %esi
callq 0x3100
callq 0x30a0
movq -0x60(%rbp), %rdi
callq 0xa6d0
movq -0x60(%rbp), %rdi
callq 0xa5f0
jmp 0xbde5
leaq -0x41(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x35e0
movq -0x78(%rbp), %rdx
leaq 0x8dc(%rip), %rsi       # 0xc665
leaq -0x40(%rbp), %rdi
callq 0x42f0
jmp 0xbd94
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xaf80
jmp 0xbda3
leaq -0x40(%rbp), %rdi
callq 0x3200
leaq -0x41(%rbp), %rdi
callq 0x3400
jmp 0xbde5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xbdda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3200
leaq -0x41(%rbp), %rdi
callq 0x3400
jmp 0xbdf0
jmp 0xbde7
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x35d0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0x34f0
movzwl -0x18(%rbp), %edi
subl $0x1, %edi
xorl %esi, %esi
leaq 0x834(%rip), %rdx       # 0xc671
movb $0x0, %al
callq 0x34d0
movq -0x20(%rbp), %rdi
callq 0x9ce0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa7b0
addq $0x20, %rsp
popq %rbp
retq
// File: zengfenfei[P]codility/src/CyclicRotation.cpp
// Function: solution(std::vector<int, std::allocator<int>>&, int)
vector<int> solution(vector<int> &A, int K) {
	int n = A.size();
	vector<int> rotated(n);
	if (n == 0) {
		return rotated;
	}
	K = K % n;
	//Move the first part to end
	for (int i = K; i < n; i++) {
		rotated[i] = A[i - K];
	}

	//Move the shifted part to the beginning
	for (int i = 0; i < K; i++) {
		rotated[i] = A[i + n - K];
	}
	return rotated;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15b0
movl %eax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x15d0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x15f0
jmp 0x1296
leaq -0x1a(%rbp), %rdi
callq 0x1660
cmpl $0x0, -0x18(%rbp)
jne 0x12cf
movb $0x1, -0x19(%rbp)
movl $0x1, -0x30(%rbp)
jmp 0x136c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x1660
jmp 0x1385
movl -0x14(%rbp), %eax
cltd
idivl -0x18(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x131b
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
subl -0x14(%rbp), %eax
movslq %eax, %rsi
callq 0x1680
movq -0x50(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
movslq -0x34(%rbp), %rsi
callq 0x1680
movl -0x5c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x12df
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1361
movq -0x10(%rbp), %rdi
movl -0x38(%rbp), %eax
addl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movslq %eax, %rsi
callq 0x1680
movq -0x50(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x60(%rbp)
movslq -0x38(%rbp), %rsi
callq 0x1680
movl -0x60(%rbp), %ecx
movl %ecx, (%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1322
movb $0x1, -0x19(%rbp)
movl $0x1, -0x30(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x137b
movq -0x50(%rbp), %rdi
callq 0x16a0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x10f0
nop
// File: zengfenfei[P]codility/src/CyclicRotation.cpp
// Function: printVector(std::vector<int, std::allocator<int>>)
void printVector(vector<int> out) {
	cout << "[";
	for (int i = 0; i < out.size(); i++) {
		cout << out[i] << ",";
	}
	cout << "]";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x4c31(%rip), %rdi      # 0x5fd8
leaq 0x1c56(%rip), %rsi      # 0x3004
callq 0x1090
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x15b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x140c
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x1680
movl (%rax), %esi
movq 0x4beb(%rip), %rdi      # 0x5fd8
callq 0x10e0
movq %rax, %rdi
leaq 0x1c0a(%rip), %rsi      # 0x3006
callq 0x1090
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x13ba
movq 0x4bc5(%rip), %rdi      # 0x5fd8
leaq 0x1bee(%rip), %rsi      # 0x3008
callq 0x1090
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
movaps 0x1bfe(%rip), %xmm0     # 0x3040
movaps %xmm0, -0x20(%rbp)
movl $0x6, -0x10(%rbp)
leaq -0xc(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x15d0
movq -0xb0(%rbp), %rdx
movq -0xa8(%rbp), %rcx
leaq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1700
jmp 0x1485
leaq -0x39(%rbp), %rdi
callq 0x1660
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x3, %edx
callq 0x1240
jmp 0x14a2
leaq -0x80(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1780
jmp 0x14b1
leaq -0x80(%rbp), %rdi
callq 0x1390
jmp 0x14bc
leaq -0x80(%rbp), %rdi
callq 0x16a0
xorps %xmm0, %xmm0
movaps %xmm0, -0xa0(%rbp)
movq $0x0, -0x90(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1870
movq -0xb8(%rbp), %rdi
callq 0x1390
jmp 0x14fb
leaq -0xa0(%rbp), %rdi
callq 0x16a0
leaq -0x68(%rbp), %rdi
callq 0x16a0
leaq -0x38(%rbp), %rdi
callq 0x16a0
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x1660
jmp 0x1598
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x158f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1586
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x16a0
jmp 0x1586
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x16a0
leaq -0x68(%rbp), %rdi
callq 0x16a0
leaq -0x38(%rbp), %rdi
callq 0x16a0
movq -0x48(%rbp), %rdi
callq 0x10f0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x8c0, %rsp            # imm = 0x8C0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x840(%rbp), %rdi
movq %rdi, -0x8b0(%rbp)
xorl %edx, %edx
callq 0x9470
movq -0x8b0(%rbp), %rdi
callq 0x7530
movb %al, -0x8a1(%rbp)
jmp 0x6f5c
movb -0x8a1(%rbp), %al
testb $0x1, %al
jne 0x6f95
jmp 0x6f68
movl $0x4, -0x4(%rbp)
movl $0x1, -0x850(%rbp)
jmp 0x7057
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x848(%rbp)
movl %eax, -0x84c(%rbp)
jmp 0x706f
movq -0x10(%rbp), %rdx
leaq -0x8a0(%rbp), %rdi
leaq -0x840(%rbp), %rsi
movl $0x1, %ecx
callq 0x20500
jmp 0x6fb3
leaq -0x8a0(%rbp), %rdi
callq 0x7950
movb %al, -0x8b1(%rbp)
jmp 0x6fc7
movb -0x8b1(%rbp), %al
testb $0x1, %al
jne 0x7006
jmp 0x6fd3
movl $0x5, -0x4(%rbp)
movl $0x1, -0x850(%rbp)
jmp 0x704b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x848(%rbp)
movl %eax, -0x84c(%rbp)
leaq -0x8a0(%rbp), %rdi
callq 0x20b70
jmp 0x706f
leaq -0x840(%rbp), %rdi
callq 0xe450
jmp 0x7014
leaq -0x840(%rbp), %rdi
movl $0x1, %esi
callq 0xe1e0
jmp 0x7027
leaq -0x8a0(%rbp), %rdi
movl $0x1, %esi
callq 0x22e80
jmp 0x703a
movl $0x0, -0x4(%rbp)
movl $0x1, -0x850(%rbp)
leaq -0x8a0(%rbp), %rdi
callq 0x20b70
leaq -0x840(%rbp), %rdi
callq 0xb5f0
movl -0x4(%rbp), %eax
addq $0x8c0, %rsp            # imm = 0x8C0
popq %rbp
retq
leaq -0x840(%rbp), %rdi
callq 0xb5f0
movq -0x848(%rbp), %rdi
callq 0x3570
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x8c0, %rsp            # imm = 0x8C0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x848(%rbp), %rdi
movq %rdi, -0x8b8(%rbp)
xorl %edx, %edx
callq 0x9470
movq -0x8b8(%rbp), %rdi
callq 0x7530
movb %al, -0x8a9(%rbp)
jmp 0x70d0
movb -0x8a9(%rbp), %al
testb $0x1, %al
jne 0x7109
jmp 0x70dc
movl $0x4, -0x4(%rbp)
movl $0x1, -0x858(%rbp)
jmp 0x722a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x850(%rbp)
movl %eax, -0x854(%rbp)
jmp 0x7242
movq -0x10(%rbp), %rdx
leaq -0x8a8(%rbp), %rdi
leaq -0x848(%rbp), %rsi
xorl %ecx, %ecx
callq 0x20500
jmp 0x7124
leaq -0x8a8(%rbp), %rdi
callq 0x7950
movb %al, -0x8b9(%rbp)
jmp 0x7138
movb -0x8b9(%rbp), %al
testb $0x1, %al
jne 0x717d
jmp 0x7144
movl $0x5, -0x4(%rbp)
movl $0x1, -0x858(%rbp)
jmp 0x721e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x850(%rbp)
movl %eax, -0x854(%rbp)
leaq -0x8a8(%rbp), %rdi
callq 0x20b70
jmp 0x7242
movq -0x18(%rbp), %rsi
leaq -0x8a8(%rbp), %rdi
movl $0x1, %edx
callq 0x213e0
jmp 0x7194
leaq -0x8a8(%rbp), %rdi
callq 0x79d0
movb %al, -0x8ba(%rbp)
jmp 0x71a8
movb -0x8ba(%rbp), %al
testb $0x1, %al
jne 0x71c7
jmp 0x71b4
movl $0x6, -0x4(%rbp)
movl $0x1, -0x858(%rbp)
jmp 0x721e
movq -0x10(%rbp), %rsi
leaq -0x8a8(%rbp), %rdi
callq 0x22bb0
jmp 0x71d9
leaq -0x848(%rbp), %rdi
callq 0xe450
jmp 0x71e7
leaq -0x848(%rbp), %rdi
movl $0x1, %esi
callq 0xe1e0
jmp 0x71fa
leaq -0x8a8(%rbp), %rdi
movl $0x1, %esi
callq 0x22e80
jmp 0x720d
movl $0x0, -0x4(%rbp)
movl $0x1, -0x858(%rbp)
leaq -0x8a8(%rbp), %rdi
callq 0x20b70
leaq -0x848(%rbp), %rdi
callq 0xb5f0
movl -0x4(%rbp), %eax
addq $0x8c0, %rsp            # imm = 0x8C0
popq %rbp
retq
leaq -0x848(%rbp), %rdi
callq 0xb5f0
movq -0x850(%rbp), %rdi
callq 0x3570
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, 0x10(%rax)
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1eff1
movq -0x18(%rbp), %rdi
callq 0x1c250
movq -0x18(%rbp), %rdi
movl $0x18, %esi
callq 0x32f0
movq -0x20(%rbp), %rax
movq $0x0, 0x40(%rax)
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1f022
movq -0x28(%rbp), %rdi
callq 0x1efb0
movq -0x28(%rbp), %rdi
movl $0x48, %esi
callq 0x32f0
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1f084
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x20(%rax), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1f082
movq -0x30(%rbp), %rdi
callq 0x1efb0
movq -0x30(%rbp), %rdi
movl $0x48, %esi
callq 0x32f0
jmp 0x1f02e
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x18(%rax)
jne 0x1f1a0
jmp 0x1f254
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
movl %ecx, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1f21e
jmp 0x1f1c3
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x1f1f2
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0xc(%rbp), %ecx
callq 0x1f260
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1f1c3
movq -0x20(%rbp), %rdi
callq 0x1f180
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1f1ba
jmp 0x1f220
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x8(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jae 0x1f254
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
callq 0x1f260
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1f220
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x48, %edi
callq 0x32e0
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x1c(%rbp), %rdx
movq %rdx, %rsi
callq 0x7710
jmp 0x1f29f
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rdx
xorl %esi, %esi
callq 0x1ef50
jmp 0x1f2b0
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0x1f2f5
movq -0x50(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x1f301
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x48, %esi
callq 0x32f0
jmp 0x1f317
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3570