LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jeffreyan11[P]go-engine/board.cpp
// Function: Board::prettyPrint()
void Board::prettyPrint() {
    // Since the y axis indexing is inverted
    for (int j = boardSize; j >= 1; j--) {
        if (j >= 10)
            std::cout << j << " ";
        else
            std::cout << " " << j << " ";

        for (int i = 1; i <= boardSize; i++) {
            if (pieces[index(i, j)] == EMPTY)
                std::cout << ". ";
            else if (pieces[index(i, j)] == BLACK)
                std::cout << "B ";
            else
                std::cout << "W ";
        }

        if (j >= 10)
            std::cout << j << " ";
        else
            std::cout << " " << j << " ";
        std::cout << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0xbb56(%rip), %eax      # 0x141f0
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0x881d
cmpl $0xa, -0xc(%rbp)
jl 0x86cd
movl -0xc(%rbp), %esi
movq 0xb901(%rip), %rdi      # 0x13fb8
callq 0x2340
movq %rax, %rdi
leaq 0x7a43(%rip), %rsi      # 0x10109
callq 0x21f0
jmp 0x86fa
movq 0xb8e4(%rip), %rdi      # 0x13fb8
leaq 0x7a2e(%rip), %rsi      # 0x10109
callq 0x21f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2340
movq %rax, %rdi
leaq 0x7a14(%rip), %rsi      # 0x10109
callq 0x21f0
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0xbae6(%rip), %eax      # 0x141f0
jg 0x87a9
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x8bc0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x874a
movq 0xb87c(%rip), %rdi      # 0x13fb8
leaq 0x78c1(%rip), %rsi      # 0x10004
callq 0x21f0
jmp 0x8799
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x8bc0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x8784
movq 0xb842(%rip), %rdi      # 0x13fb8
leaq 0x788a(%rip), %rsi      # 0x10007
callq 0x21f0
jmp 0x8797
movq 0xb82d(%rip), %rdi      # 0x13fb8
leaq 0x7878(%rip), %rsi      # 0x1000a
callq 0x21f0
jmp 0x8799
jmp 0x879b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8701
cmpl $0xa, -0xc(%rbp)
jl 0x87cf
movl -0xc(%rbp), %esi
movq 0xb7ff(%rip), %rdi      # 0x13fb8
callq 0x2340
movq %rax, %rdi
leaq 0x7941(%rip), %rsi      # 0x10109
callq 0x21f0
jmp 0x87fc
movq 0xb7e2(%rip), %rdi      # 0x13fb8
leaq 0x792c(%rip), %rsi      # 0x10109
callq 0x21f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2340
movq %rax, %rdi
leaq 0x7912(%rip), %rsi      # 0x10109
callq 0x21f0
movq 0xb7b5(%rip), %rdi      # 0x13fb8
movq 0xb796(%rip), %rsi      # 0x13fa0
callq 0x2230
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x869d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jeffreyan11[P]go-engine/board.cpp
// Function: Board::errorPrint()
void Board::errorPrint() {
    // Since the y axis indexing is inverted
    for (int j = boardSize; j >= 1; j--) {
        if (j >= 10)
            std::cerr << j << " ";
        else
            std::cerr << " " << j << " ";

        for (int i = 1; i <= boardSize; i++) {
            if (pieces[index(i, j)] == EMPTY)
                std::cerr << ". ";
            else if (pieces[index(i, j)] == BLACK)
                std::cerr << "B ";
            else
                std::cerr << "W ";
        }

        if (j >= 10)
            std::cerr << j << " ";
        else
            std::cerr << " " << j << " ";
        std::cerr << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0xb9a6(%rip), %eax      # 0x141f0
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0x89cd
cmpl $0xa, -0xc(%rbp)
jl 0x887d
movl -0xc(%rbp), %esi
movq 0xb789(%rip), %rdi      # 0x13ff0
callq 0x2340
movq %rax, %rdi
leaq 0x7893(%rip), %rsi      # 0x10109
callq 0x21f0
jmp 0x88aa
movq 0xb76c(%rip), %rdi      # 0x13ff0
leaq 0x787e(%rip), %rsi      # 0x10109
callq 0x21f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2340
movq %rax, %rdi
leaq 0x7864(%rip), %rsi      # 0x10109
callq 0x21f0
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0xb936(%rip), %eax      # 0x141f0
jg 0x8959
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x8bc0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x88fa
movq 0xb704(%rip), %rdi      # 0x13ff0
leaq 0x7711(%rip), %rsi      # 0x10004
callq 0x21f0
jmp 0x8949
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x8bc0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x8934
movq 0xb6ca(%rip), %rdi      # 0x13ff0
leaq 0x76da(%rip), %rsi      # 0x10007
callq 0x21f0
jmp 0x8947
movq 0xb6b5(%rip), %rdi      # 0x13ff0
leaq 0x76c8(%rip), %rsi      # 0x1000a
callq 0x21f0
jmp 0x8949
jmp 0x894b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x88b1
cmpl $0xa, -0xc(%rbp)
jl 0x897f
movl -0xc(%rbp), %esi
movq 0xb687(%rip), %rdi      # 0x13ff0
callq 0x2340
movq %rax, %rdi
leaq 0x7791(%rip), %rsi      # 0x10109
callq 0x21f0
jmp 0x89ac
movq 0xb66a(%rip), %rdi      # 0x13ff0
leaq 0x777c(%rip), %rsi      # 0x10109
callq 0x21f0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2340
movq %rax, %rdi
leaq 0x7762(%rip), %rsi      # 0x10109
callq 0x21f0
movq 0xb63d(%rip), %rdi      # 0x13ff0
movq 0xb5e6(%rip), %rsi      # 0x13fa0
callq 0x2230
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x884d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jeffreyan11[P]go-engine/board.cpp
// Function: Board::searchChainsByID(Chain*&, int)
inline int Board::searchChainsByID(Chain *&node, int id) {
    for (unsigned int i = 0; i < chainList.size(); i++) {
        if (chainList.get(i)->id == id) {
            node = chainList.get(i);
            return i;
        }
    }

    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x28, %rdi
callq 0x8b00
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jae 0x8cd4
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movl -0x20(%rbp), %esi
callq 0x8b20
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x8cc7
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
movl -0x20(%rbp), %esi
callq 0x8b20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8cdb
jmp 0x8cc9
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8c72
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: jeffreyan11[P]go-engine/board.cpp
// Function: int Board::doCaptures<false>(int, unsigned short)
int Board::doCaptures(Player victim, Move seed) {
    if (pieces[index(getX(seed), getY(seed))] != victim)
        return 0;

    Stone *visited = new Stone[arraySize*arraySize];
    for (int i = 0; i < arraySize*arraySize; i++) {
        visited[i] = 0;
    }
    MoveList captured;

    if (isSurrounded(victim, EMPTY, getX(seed), getY(seed), visited, captured)) {
        if (updateBoard) {
            for (unsigned int i = 0; i < captured.size(); i++) {
                Move m = captured.get(i);
                pieces[index(getX(m), getY(m))] = EMPTY;
                zobristKey ^= zobristTable[zobristIndex(victim, getX(m), getY(m))];
            }

            // Record how many pieces were captured for scoring purposes
            if (victim == BLACK)
                whiteCaptures += captured.size();
            else
                blackCaptures += captured.size();
        }
    }

    delete[] visited;
    return captured.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp            # imm = 0x480
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movw %ax, -0x16(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x450(%rbp)
movq (%rax), %rax
movq %rax, -0x440(%rbp)
movzwl -0x16(%rbp), %edi
callq 0x8b80
movl %eax, -0x444(%rbp)
movzwl -0x16(%rbp), %edi
callq 0x8ba0
movl -0x444(%rbp), %edi
movl %eax, %esi
callq 0x8bc0
movl %eax, %ecx
movq -0x440(%rbp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
je 0x8d63
movl $0x0, -0x4(%rbp)
jmp 0x8eaa
movl 0xb48b(%rip), %eax      # 0x141f4
imull 0xb484(%rip), %eax      # 0x141f4
cltq
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl 0xb44d(%rip), %ecx      # 0x141f4
imull 0xb446(%rip), %ecx      # 0x141f4
cmpl %ecx, %eax
jge 0x8dcc
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8d9e
leaq -0x428(%rbp), %rdi
movq %rdi, -0x468(%rbp)
callq 0x8ed0
movl -0x14(%rbp), %eax
movl %eax, -0x45c(%rbp)
movzwl -0x16(%rbp), %edi
callq 0x8b80
movl %eax, -0x458(%rbp)
movzwl -0x16(%rbp), %edi
callq 0x8ba0
movq -0x468(%rbp), %rdx
movq -0x450(%rbp), %rdi
movl -0x45c(%rbp), %esi
movl -0x458(%rbp), %ecx
movl %eax, %r8d
movq -0x20(%rbp), %r9
movq %rsp, %rax
movq %rdx, (%rax)
xorl %edx, %edx
callq 0x5e20
movb %al, -0x451(%rbp)
jmp 0x8e36
movb -0x451(%rbp), %al
testb $0x1, %al
jne 0x8e42
jmp 0x8e64
jmp 0x8e64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x430(%rbp)
movl %eax, -0x434(%rbp)
leaq -0x428(%rbp), %rdi
callq 0x8f30
jmp 0x8eb6
movq -0x20(%rbp), %rax
movq %rax, -0x470(%rbp)
cmpq $0x0, %rax
je 0x8e81
movq -0x470(%rbp), %rdi
callq 0x22a0
leaq -0x428(%rbp), %rdi
callq 0x92b0
movl %eax, -0x474(%rbp)
jmp 0x8e95
movl -0x474(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x428(%rbp), %rdi
callq 0x8f30
movl -0x4(%rbp), %eax
addq $0x480, %rsp            # imm = 0x480
popq %rbp
retq
movq -0x430(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jeffreyan11[P]go-engine/chain.cpp
// Function: Chain::Chain(int, int)
Chain::Chain(Player p, int _id) {
	id = _id;
	color = p;
	size = 0;
	liberties = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
popq %rbp
retq
nopl (%rax)
// File: jeffreyan11[P]go-engine/chain.cpp
// Function: Chain::Chain(Chain const&)
Chain::Chain(const Chain &other) {
	id = other.id;
	color = other.color;
	size = other.size;
	liberties = other.liberties;
	for (int i = 0; i < size; i++)
		squares[i] = other.squares[i];
	for (int i = 0; i < liberties; i++)
		libertyList[i] = other.libertyList[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x9372
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movw 0x10(%rcx,%rdx,2), %dx
movslq -0x14(%rbp), %rcx
movw %dx, 0x10(%rax,%rcx,2)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9341
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x93b0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movw 0x410(%rcx,%rdx,2), %dx
movslq -0x18(%rbp), %rcx
movw %dx, 0x410(%rax,%rcx,2)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9379
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jeffreyan11[P]go-engine/chain.cpp
// Function: Chain::findLiberty(unsigned short)
int Chain::findLiberty(Move m) {
	int index = -1;
	for (int i = 0; i < liberties; i++) {
		if (libertyList[i] == m) {
			index = i;
			break;
		}
	}
	return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x945e
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzwl 0x410(%rax,%rcx,2), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jne 0x9451
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x945e
jmp 0x9453
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9425
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jeffreyan11[P]go-engine/mctree.cpp
// Function: MCTree::backPropagate(MCNode*)
void MCTree::backPropagate(MCNode *leaf) {
    int n = leaf->numerator;
    int d = leaf->denominator;
    int diff = leaf->scoreDiff;

    MCNode *node = leaf->parent;
    // Flip whether the game was won or not since each level of the tree is
    // from the POV of the opposing player
    n ^= 1;
    diff = -diff;
    while (node != NULL) {
        node->numerator += n;
        node->denominator += d;
        node->scoreDiff += diff;
        n ^= 1;
        diff = -diff;
        node = node->parent;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x97d5
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x28(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movslq -0x1c(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x9787
popq %rbp
retq
nopw (%rax,%rax)
// File: jeffreyan11[P]go-engine/search.cpp
// Function: scoreGame(int, Board&, float&, float&)
void scoreGame(Player p, Board &b, float &myScore, float &oppScore) {
    int whiteTerritory = 0, blackTerritory = 0;
    b.countTerritory(whiteTerritory, blackTerritory);

    myScore = b.getCapturedStones(p)
        + ((p == BLACK) ? blackTerritory : whiteTerritory);
    oppScore = b.getCapturedStones(otherPlayer(p))
        + ((p == BLACK) ? whiteTerritory : blackTerritory);

    if (p == WHITE)
        myScore += komi;
    else
        oppScore += komi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x6120
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x85c0
movl %eax, -0x2c(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0xb4c3
movl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0xb4c9
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movl -0x30(%rbp), %ecx
addl %ecx, %eax
cvtsi2ss %eax, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x4(%rbp), %edi
callq 0x8c10
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x85c0
movl %eax, -0x34(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0xb509
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0xb50f
movl -0x28(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x34(%rbp), %eax
movl -0x44(%rbp), %ecx
addl %ecx, %eax
cvtsi2ss %eax, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
cmpl $0x2, -0x4(%rbp)
jne 0xb53f
movss 0x8ccf(%rip), %xmm0     # 0x14200
movq -0x18(%rbp), %rax
addss (%rax), %xmm0
movss %xmm0, (%rax)
jmp 0xb553
movss 0x8cb9(%rip), %xmm0     # 0x14200
movq -0x20(%rbp), %rax
addss (%rax), %xmm0
movss %xmm0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: jeffreyan11[P]go-engine/./mctree.h
// Function: MCNode::MCNode()
MCNode() {
        numerator = 0;
        denominator = 1;
        scoreDiff = 0;
        m = 0;
        size = 0;
        parent = NULL;
        children = new MCNode *[512];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, (%rax)
movl $0x1, 0x4(%rax)
movq $0x0, 0x8(%rax)
movw $0x0, 0x10(%rax)
movw $0x0, 0x12(%rax)
movq $0x0, 0x18(%rax)
movl $0x1000, %edi           # imm = 0x1000
callq 0x2030
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jeffreyan11[P]go-engine/./types.h
// Function: GoArrayList<unsigned short>::find(unsigned short)
int find(T o) {
        int index = -1;
        for (unsigned int i = 0; i < length; i++) {
            if (arrayList[i] == o) {
                index = (int) i;
                break;
            }
        }
        return index;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x400(%rcx), %eax
jae 0xb72c
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jne 0xb71f
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xb72c
jmp 0xb721
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb6f5
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: jeffreyan11[P]go-engine/search.cpp
// Function: HistoryTable::max()
int max() {
        int result = -(1 << 30);
        for (int i = 0; i < 23; i++)
            for (int j = 0; j < 23; j++)
                if (data[i][j] > result)
                    result = data[i][j];
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0xc0000000, -0xc(%rbp) # imm = 0xC0000000
movl $0x0, -0x10(%rbp)
cmpl $0x17, -0x10(%rbp)
jge 0xb93f
movl $0x0, -0x14(%rbp)
cmpl $0x17, -0x14(%rbp)
jge 0xb932
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x5c, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
jle 0xb925
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x5c, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
jmp 0xb927
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb8eb
jmp 0xb934
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb8de
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: jeffreyan11[P]go-engine/./mctree.h
// Function: MCNode::cleanup()
void cleanup() {
        for (int i = 0; i < size; i++) {
            children[i]->cleanup();
            delete children[i];
        }
        delete[] children;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movswl 0x12(%rcx), %ecx
cmpl %ecx, %eax
jge 0xbb3d
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xbac0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xbb30
movq -0x20(%rbp), %rdi
callq 0xbb60
movq -0x20(%rbp), %rdi
movl $0x28, %esi
callq 0x2210
jmp 0xbb32
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbadb
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xbb58
movq -0x28(%rbp), %rdi
callq 0x22a0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: jeffreyan11[P]go-engine/gtp.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector<string> split(const string &s, char d) {
    vector<string> v;
    stringstream ss(s);
    string item;
    while (getline(ss, item, d)) {
        v.push_back(item);
    }
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1f0(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0xe260
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0xe280
movl %eax, -0x1d4(%rbp)
jmp 0xdd24
movl -0x1d4(%rbp), %edx
movq -0x1e0(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
callq 0x2310
jmp 0xdd3f
leaq -0x1d0(%rbp), %rdi
callq 0x22c0
movsbl -0x11(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x2380
movq %rax, -0x1f8(%rbp)
jmp 0xdd6b
movq -0x1f8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2290
movb %al, -0x1f9(%rbp)
jmp 0xdd89
movb -0x1f9(%rbp), %al
testb $0x1, %al
jne 0xdd95
jmp 0xddec
movq -0x1f0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0xe2a0
jmp 0xddaa
jmp 0xdd4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0xde2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x23c8
leaq -0x1a0(%rbp), %rdi
callq 0x2160
jmp 0xde2a
movb $0x1, -0x12(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x23c8
leaq -0x1a0(%rbp), %rdi
callq 0x2160
testb $0x1, -0x12(%rbp)
jne 0xde1a
movq -0x1f0(%rbp), %rdi
callq 0xe200
movq -0x1e8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1f0(%rbp), %rdi
callq 0xe200
movq -0x1a8(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: jeffreyan11[P]go-engine/gtp.cpp
// Function: stringToColor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Player stringToColor(string colorString) {
    if (colorString == "black" || colorString == "b" || colorString == "B")
        return BLACK;
    else if (colorString == "white" || colorString == "w" || colorString == "W")
        return WHITE;
    else
        return EMPTY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x2355(%rip), %rsi      # 0x101bc
callq 0xe030
testb $0x1, %al
jne 0xde9a
movq -0x18(%rbp), %rdi
leaq 0x2347(%rip), %rsi      # 0x101c2
callq 0xe030
testb $0x1, %al
jne 0xde9a
movq -0x18(%rbp), %rdi
leaq 0x2245(%rip), %rsi      # 0x100d4
callq 0xe030
testb $0x1, %al
jne 0xde9a
jmp 0xdea3
movl $0x1, -0x4(%rbp)
jmp 0xdef1
movq -0x18(%rbp), %rdi
leaq 0x2316(%rip), %rsi      # 0x101c4
callq 0xe030
testb $0x1, %al
jne 0xdee1
movq -0x18(%rbp), %rdi
leaq 0x2308(%rip), %rsi      # 0x101ca
callq 0xe030
testb $0x1, %al
jne 0xdee1
movq -0x18(%rbp), %rdi
leaq 0x2224(%rip), %rsi      # 0x100fa
callq 0xe030
testb $0x1, %al
jne 0xdee1
jmp 0xdeea
movl $0x2, -0x4(%rbp)
jmp 0xdef1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: willprice[P]parallel-cpp-workshop/map.cpp
// Function: main
int main(int argc, char **argv)
{
    auto a = std::vector<int>( { 1, 2, 3, 4, 5 } );
    auto b = std::vector<int>( { 6, 7, 8, 9, 10 } );

    print_vector(map_fn(sum, a, b));
    print_vector(map_fn(difference, a, b));
    print_vector(map_fn(multiply, a, b));

    return 0;
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movl $0x0, 0x114(%rsp)
movl %edi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movups 0x1d2c(%rip), %xmm0     # 0x3004
movaps %xmm0, 0xc0(%rsp)
movl $0x5, 0xd0(%rsp)
leaq 0xc0(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq $0x5, 0xe8(%rsp)
leaq 0xbf(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1580
movq 0x8(%rsp), %rcx
movq 0xe0(%rsp), %rsi
movq 0xe8(%rsp), %rdx
leaq 0xf0(%rsp), %rdi
callq 0x1590
jmp 0x133d
leaq 0xbf(%rsp), %rdi
callq 0x1620
movups 0x1cc7(%rip), %xmm0     # 0x3018
movaps %xmm0, 0x60(%rsp)
movl $0xa, 0x70(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, 0x80(%rsp)
movq $0x5, 0x88(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x1580
movq (%rsp), %rcx
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
leaq 0x90(%rsp), %rdi
callq 0x1590
jmp 0x13a8
leaq 0x5f(%rsp), %rdi
callq 0x1620
leaq -0x169(%rip), %rsi      # 0x1250
leaq 0x40(%rsp), %rdi
leaq 0xf0(%rsp), %rdx
leaq 0x90(%rsp), %rcx
callq 0x16f0
jmp 0x13d5
leaq 0x40(%rsp), %rdi
callq 0x1630
jmp 0x13e1
leaq 0x40(%rsp), %rdi
callq 0x1890
leaq -0x162(%rip), %rsi      # 0x1290
leaq 0x28(%rsp), %rdi
leaq 0xf0(%rsp), %rdx
leaq 0x90(%rsp), %rcx
callq 0x16f0
jmp 0x140e
leaq 0x28(%rsp), %rdi
callq 0x1630
jmp 0x141a
leaq 0x28(%rsp), %rdi
callq 0x1890
leaq -0x1bb(%rip), %rsi      # 0x1270
leaq 0x10(%rsp), %rdi
leaq 0xf0(%rsp), %rdx
leaq 0x90(%rsp), %rcx
callq 0x16f0
jmp 0x1447
leaq 0x10(%rsp), %rdi
callq 0x1630
jmp 0x1453
leaq 0x10(%rsp), %rdi
callq 0x1890
movl $0x0, 0x114(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x1890
leaq 0xf0(%rsp), %rdi
callq 0x1890
movl 0x114(%rsp), %eax
addq $0x118, %rsp            # imm = 0x118
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0xbf(%rsp), %rdi
callq 0x1620
jmp 0x1568
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x5f(%rsp), %rdi
callq 0x1620
jmp 0x155b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0x154e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1890
jmp 0x154e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1890
jmp 0x154e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x1890
leaq 0x90(%rsp), %rdi
callq 0x1890
leaq 0xf0(%rsp), %rdi
callq 0x1890
movq 0xb0(%rsp), %rdi
callq 0x1100
nopw %cs:(%rax,%rax)
nop
// File: willprice[P]parallel-cpp-workshop/map.cpp
// Function: void print_vector<int>(std::vector<int, std::allocator<int>> const&)
void print_vector(const std::vector<T> &values)
{
    std::cout << "[";

    for (const T &value : values)
    {
        std::cout << " " << value;
    }

    std::cout << " ]" << std::endl;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x3998(%rip), %rdi      # 0x4fd8
leaq 0x1a16(%rip), %rsi      # 0x305d
callq 0x1090
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2680
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x26b0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x26e0
testb $0x1, %al
jne 0x1689
jmp 0x16c4
leaq 0x10(%rsp), %rdi
callq 0x2720
movq %rax, (%rsp)
movq 0x393a(%rip), %rdi      # 0x4fd8
leaq 0x19ba(%rip), %rsi      # 0x305f
callq 0x1090
movq %rax, %rdi
movq (%rsp), %rax
movl (%rax), %esi
callq 0x10f0
leaq 0x10(%rsp), %rdi
callq 0x2730
jmp 0x1674
movq 0x390d(%rip), %rdi      # 0x4fd8
leaq 0x198f(%rip), %rsi      # 0x3061
callq 0x1090
movq %rax, %rdi
movq 0x38e7(%rip), %rsi      # 0x4fc8
callq 0x10c0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: willprice[P]parallel-cpp-workshop/map.cpp
// Function: auto map_fn<int (*)(int, int), int>(int (*)(int, int), std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
auto map_fn(Fn fn, std::vector<T> &xs, std::vector<T> &ys)
{
    int len = std::min(xs.size(), ys.size());
    auto result = std::vector<T>(len);

    for (int i = 0; i < len; i++) {
      result[i] = fn(xs[i], ys[i]);
    }

    return result;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq 0x90(%rsp), %rdi
callq 0x1930
movq %rax, 0x78(%rsp)
movq 0x88(%rsp), %rdi
callq 0x1930
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x18f0
movl (%rax), %eax
movl %eax, 0x84(%rsp)
movslq 0x84(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x1580
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0x1950
jmp 0x1792
leaq 0x57(%rsp), %rdi
callq 0x1620
movl $0x0, 0x40(%rsp)
movl 0x40(%rsp), %eax
cmpl 0x84(%rsp), %eax
jge 0x1858
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x90(%rsp), %rdi
movslq 0x40(%rsp), %rsi
callq 0x19d0
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x88(%rsp), %rdi
movslq 0x40(%rsp), %rsi
callq 0x19d0
movl 0xc(%rsp), %edi
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl (%rcx), %esi
callq *%rax
movl %eax, 0x1c(%rsp)
jmp 0x1802
movslq 0x40(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x19d0
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x17a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x57(%rsp), %rdi
callq 0x1620
jmp 0x187e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1890
jmp 0x187e
movq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x19f0
leaq 0x58(%rsp), %rdi
callq 0x1890
movq 0x28(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x1100
nopl (%rax,%rax)
// File: kiven-li[P]xbytes/main.cpp
// Function: main
int main(int argc, char *argv[])
{
	if(argc < 2)
	{
		std::cout << "x-bytes: need rule file name." << std::endl;
		return 1;
	}

    xbytes::xbytes x;
    x.make_parser(argv[1]);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x710, %rsp            # imm = 0x710
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x373d
movq 0x208c2(%rip), %rdi     # 0x23fd8
leaq 0x158e7(%rip), %rsi     # 0x19004
callq 0x32e0
movq %rax, %rdi
movq 0x2089c(%rip), %rsi     # 0x23fc8
callq 0x3320
movl $0x1, -0x4(%rbp)
jmp 0x3815
leaq -0x6c0(%rbp), %rdi
callq 0x3b80
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x708(%rbp)
leaq -0x6e1(%rbp), %rdi
movq %rdi, -0x700(%rbp)
callq 0x34f0
movq -0x708(%rbp), %rsi
movq -0x700(%rbp), %rdx
leaq -0x6e0(%rbp), %rdi
callq 0x3830
jmp 0x3787
leaq -0x6c0(%rbp), %rdi
leaq -0x6e0(%rbp), %rsi
callq 0x4290
jmp 0x379c
leaq -0x6e0(%rbp), %rdi
callq 0x31b0
leaq -0x6e1(%rbp), %rdi
callq 0x3340
movl $0x0, -0x4(%rbp)
leaq -0x6c0(%rbp), %rdi
callq 0x3fe0
jmp 0x3815
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x6f0(%rbp)
movl %eax, -0x6f4(%rbp)
jmp 0x37fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x6f0(%rbp)
movl %eax, -0x6f4(%rbp)
leaq -0x6e0(%rbp), %rdi
callq 0x31b0
leaq -0x6e1(%rbp), %rdi
callq 0x3340
leaq -0x6c0(%rbp), %rdi
callq 0x3fe0
jmp 0x3821
movl -0x4(%rbp), %eax
addq $0x710, %rsp            # imm = 0x710
popq %rbp
retq
movq -0x6f0(%rbp), %rdi
callq 0x34e0
nopl (%rax)
// File: kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::error_on_line(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void xbytes::error_on_line(const char* line, const string& error, int space)
{
	std::cout << "ERROR:" << std::endl;
	std::cout << "  line: " << line_count+1 << std::endl;
	std::cout << "  info: Don't parse program file, There is an error:[[" << std::endl;
	std::cout << line << std::endl;
	for(int i = 0; i < space; ++i)
	{
		std::cout << ' ';
	}
	std::cout << "^" << std::endl;
	std::cout << "  " << error << "]]" << std::endl;

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x1e4d2(%rip), %rdi     # 0x23fd8
leaq 0x13a6e(%rip), %rsi     # 0x1957b
callq 0x32e0
movq %rax, %rdi
movq 0x1e4ac(%rip), %rsi     # 0x23fc8
callq 0x3320
movq 0x1e4b0(%rip), %rdi     # 0x23fd8
leaq 0x13a53(%rip), %rsi     # 0x19582
callq 0x32e0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movl 0x60c(%rax), %esi
addl $0x1, %esi
callq 0x34d0
movq %rax, %rdi
movq 0x1e475(%rip), %rsi     # 0x23fc8
callq 0x3320
movq 0x1e479(%rip), %rdi     # 0x23fd8
leaq 0x13a25(%rip), %rsi     # 0x1958b
callq 0x32e0
movq %rax, %rdi
movq 0x1e453(%rip), %rsi     # 0x23fc8
callq 0x3320
movq -0x10(%rbp), %rsi
movq 0x1e453(%rip), %rdi     # 0x23fd8
callq 0x32e0
movq %rax, %rdi
movq 0x1e434(%rip), %rsi     # 0x23fc8
callq 0x3320
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5bc4
movq 0x1e429(%rip), %rdi     # 0x23fd8
movl $0x20, %esi
callq 0x3390
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5ba0
movq 0x1e40d(%rip), %rdi     # 0x23fd8
leaq 0x139f0(%rip), %rsi     # 0x195c2
callq 0x32e0
movq %rax, %rdi
movq 0x1e3e7(%rip), %rsi     # 0x23fc8
callq 0x3320
movq 0x1e3eb(%rip), %rdi     # 0x23fd8
leaq 0x139d0(%rip), %rsi     # 0x195c4
callq 0x32e0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3290
movq %rax, %rdi
leaq 0x139b8(%rip), %rsi     # 0x195c7
callq 0x32e0
movq %rax, %rdi
movq 0x1e3aa(%rip), %rsi     # 0x23fc8
callq 0x3320
movl $0x1, %edi
callq 0x33a0
nopl (%rax)
// File: kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::sort_symbol()
void xbytes::sort_symbol()
{
	symbol_array terminals;
	symbol_array nonterminals;

	for(int i = 0; i < symbols.size(); ++i)
	{
		symbol* s = symbols[i];
		if(s->type == ST_TERMINAL) 
			terminals.push_back(s);
		else
			nonterminals.push_back(s);
	}
	for(int i = 0; i < terminals.size(); ++i)
	{
		symbols[i] = terminals[i];
		symbols[i]->index = i;
	}
	for(int i = 0; i < nonterminals.size(); ++i)
	{
		int index = terminals.size() + i;
		symbols[index] = nonterminals[i];
		symbols[index]->index = index;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc190
leaq -0x38(%rbp), %rdi
callq 0xc190
movl $0x0, -0x3c(%rbp)
movq -0x68(%rbp), %rdi
movslq -0x3c(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x8, %rdi
callq 0xc4d0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x5cf8
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
movslq -0x3c(%rbp), %rsi
callq 0xc4f0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpl $0x1, 0x48(%rax)
jne 0x5cd7
leaq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc690
jmp 0x5cb2
jmp 0x5ce8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc470
leaq -0x20(%rbp), %rdi
callq 0xc470
jmp 0x5e35
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc690
jmp 0x5ce6
jmp 0x5ce8
jmp 0x5cea
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5c60
movl $0x0, -0x58(%rbp)
movslq -0x58(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc4d0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x5d78
movslq -0x58(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xc4f0
movq -0x68(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x88(%rbp)
addq $0x8, %rdi
movslq -0x58(%rbp), %rsi
callq 0xc4f0
movq -0x88(%rbp), %rcx
movq -0x68(%rbp), %rdi
movq %rcx, (%rax)
movl -0x58(%rbp), %eax
movl %eax, -0x7c(%rbp)
addq $0x8, %rdi
movslq -0x58(%rbp), %rsi
callq 0xc4f0
movl -0x7c(%rbp), %ecx
movq (%rax), %rax
movl %ecx, (%rax)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x5cff
movl $0x0, -0x5c(%rbp)
movslq -0x5c(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc4d0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x5e1a
leaq -0x20(%rbp), %rdi
callq 0xc4d0
movslq -0x5c(%rbp), %rcx
addq %rcx, %rax
movl %eax, -0x60(%rbp)
movslq -0x5c(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xc4f0
movq -0x68(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
addq $0x8, %rdi
movslq -0x60(%rbp), %rsi
callq 0xc4f0
movq -0xa0(%rbp), %rcx
movq -0x68(%rbp), %rdi
movq %rcx, (%rax)
movl -0x60(%rbp), %eax
movl %eax, -0x94(%rbp)
addq $0x8, %rdi
movslq -0x60(%rbp), %rsi
callq 0xc4f0
movl -0x94(%rbp), %ecx
movq (%rax), %rax
movl %ecx, (%rax)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x5d7f
leaq -0x38(%rbp), %rdi
callq 0xc470
leaq -0x20(%rbp), %rdi
callq 0xc470
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x34e0
nop
// File: kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::find_symbol_precedence()
void xbytes::find_symbol_precedence()
{
	//make symbol's precedence & associativity
	for(int i = 0; i < assoc_precs.size(); ++i)
	{
		int ass = assoc_precs[i].associativity;
		string_array& sa = assoc_precs[i].symbol_names;
		for(int m = 0; m < sa.size(); ++m)
		{
			symbol* s = find_symbol(sa[m]);
			if(s)
			{
				s->associativity = ass;
				s->precedence = i;
			}
		}
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x30(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x698, %rdi            # imm = 0x698
callq 0xd040
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x5f37
movq -0x30(%rbp), %rdi
addq $0x698, %rdi            # imm = 0x698
movslq -0xc(%rbp), %rsi
callq 0xd020
movq -0x30(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x10(%rbp)
addq $0x698, %rdi            # imm = 0x698
movslq -0xc(%rbp), %rsi
callq 0xd020
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd540
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x5f27
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xd560
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x9b70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5f1a
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xa4(%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xa0(%rax)
jmp 0x5f1c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5ebf
jmp 0x5f29
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5e5b
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::find_rule_precedence()
void xbytes::find_rule_precedence()
{


	//make rule's precedence
	for(int i = 0; i < rules.size(); ++i)
	{
		rule* r = rules[i];
		if(r->precedence_symbol != NULL) continue;

		for(int m = 0; m < r->rights.size() && r->precedence_symbol == NULL; ++m)
		{
			symbol* s = r->rights[m];
			if(s->type != ST_TERMINAL) continue;
			
			if(s->precedence >= 0)
			{
				r->precedence_symbol = s;
				break;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x30(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x20, %rdi
callq 0xc510
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x6055
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movslq -0xc(%rbp), %rsi
callq 0xc530
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x5fab
jmp 0x6047
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xc4d0
movq -0x48(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x39(%rbp)
jae 0x5fea
movq -0x18(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x5ff3
jmp 0x6045
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xc4f0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x1, 0x48(%rax)
je 0x6017
jmp 0x6037
movq -0x28(%rbp), %rax
cmpl $0x0, 0xa0(%rax)
jl 0x6035
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xa0(%rax)
jmp 0x6045
jmp 0x6037
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5fb2
jmp 0x6047
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5f5b
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::find_nullable()
void xbytes::find_nullable()
{
	for(int i = 0; i < symbols.size(); ++i)
	{
		symbols[i]->is_nullable = false;
	}

	while(true)
	{
		bool is_change = false;
		for(int i = 0; i < rules.size(); ++i)
		{
			rule* r = rules[i];
			if(r->left->is_nullable) continue;
			if(r->rights.size() == 0)
			{
				r->left->is_nullable = true;
				is_change = true;
				continue;
			}

			bool is_all_nullable = true;
			for(int j = 0; j < r->rights.size(); ++j)
			{
				if(!r->rights[j]->is_nullable)
				{
					is_all_nullable = false;
					break;
				}
			}

			if(is_all_nullable)
			{
				r->left->is_nullable = true;
				is_change = true;
			}
		}

		if(!is_change) break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x30(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
callq 0xc4d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x60bf
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movslq -0xc(%rbp), %rsi
callq 0xc4f0
movq (%rax), %rax
movb $0x0, 0x68(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x607b
jmp 0x60c1
movb $0x0, -0xd(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x20, %rdi
callq 0xc510
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x61c0
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movslq -0x14(%rbp), %rsi
callq 0xc530
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
testb $0x1, 0x68(%rax)
je 0x611c
jmp 0x61b2
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0xc4d0
cmpq $0x0, %rax
jne 0x6141
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x1, 0x68(%rax)
movb $0x1, -0xd(%rbp)
jmp 0x61b2
movb $0x1, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
movslq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0xc4d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x619a
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movslq -0x28(%rbp), %rsi
callq 0xc4f0
movq (%rax), %rax
testb $0x1, 0x68(%rax)
jne 0x618d
movb $0x0, -0x21(%rbp)
jmp 0x619a
jmp 0x618f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x614c
testb $0x1, -0x21(%rbp)
je 0x61b0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x1, 0x68(%rax)
movb $0x1, -0xd(%rbp)
jmp 0x61b2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x60cc
testb $0x1, -0xd(%rbp)
jne 0x61c8
jmp 0x61cd
jmp 0x60c1
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::merge_symbol_set(std::vector<xbytes::symbol*, std::allocator<xbytes::symbol*>>&, std::vector<xbytes::symbol*, std::allocator<xbytes::symbol*>>&)
int xbytes::merge_symbol_set(symbol_array& s1, symbol_array& s2)
{
	int insert_count = 0;
	for(int i = 0; i < s2.size(); ++i)
	{
		bool is_add = true;
		for(int j = 0; j < s1.size(); ++j)
		{
			if(s2[i] == s1[j])
			{
				is_add = false;
				break;
			}
		}
		if(is_add)
		{
			insert_count++;
			s1.push_back(s2[i]);
		}
	}

	return insert_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc4d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x853b
movb $0x1, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
movslq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc4d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x84fb
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xc4f0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0xc4f0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq (%rcx), %rax
jne 0x84ee
movb $0x0, -0x21(%rbp)
jmp 0x84fb
jmp 0x84f0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x849e
testb $0x1, -0x21(%rbp)
je 0x852b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0xc4f0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xc690
jmp 0x852d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8472
movl -0x1c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::make_first_state()
lr_state xbytes::make_first_state()
{
	lr_state start_state;
	start_state.state = 0;

	term* t = new term();
	t->r = start;
	t->dot = 0;

	start_state.terms.push_back(t);

	closure(start_state);

	add_lr_state(start_state);

	return start_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xc730
movq -0x40(%rbp), %rdi
movl $0x0, (%rdi)
movl $0x30, %edi
callq 0x32f0
movq %rax, -0x38(%rbp)
jmp 0x8606
movq -0x38(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0xc770
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movq %rcx, -0x20(%rbp)
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
addq $0x8, %rdi
leaq -0x20(%rbp), %rsi
callq 0xc790
jmp 0x8651
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x8a60
jmp 0x8660
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x8890
jmp 0x866f
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x869b
jmp 0x8692
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xc5f0
jmp 0x86a5
movq -0x40(%rbp), %rdi
callq 0xc5f0
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x34e0
nop
// File: kiven-li[P]xbytes/xbytes.cpp
// Function: xbytes::xbytes::lr_goto(xbytes::lr_state&, xbytes::symbol*)
lr_state xbytes::lr_goto(lr_state& state, symbol* s)
{
	lr_state next_state;
	for(int i = 0; i < state.terms.size(); ++i)
	{
		term* t = state.terms[i];
		assert(t->r != NULL);
		if(t->dot >= t->r->rights.size()) continue;
		if(t->r->rights[t->dot] == s)
		{
			term tt;
			tt.r = t->r;
			tt.dot = t->dot + 1;
			tt.forwards = t->forwards;
			add_term(next_state, tt);
		}
	}

	closure(next_state);
	return next_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x21(%rbp)
callq 0xc730
movl $0x0, -0x28(%rbp)
movslq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0xc590
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x882e
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movslq -0x28(%rbp), %rsi
callq 0xc5b0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8740
jmp 0x875f
leaq 0x10a44(%rip), %rdi     # 0x1918b
leaq 0x10a4a(%rip), %rsi     # 0x19198
movl $0x20e, %edx            # imm = 0x20E
leaq 0x10a49(%rip), %rcx     # 0x191a3
callq 0x31d0
movq -0x30(%rbp), %rax
movslq 0x8(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
addq $0x30, %rdi
callq 0xc4d0
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jb 0x8792
jmp 0x8820
movq -0x30(%rbp), %rax
movq (%rax), %rdi
addq $0x30, %rdi
movq -0x30(%rbp), %rax
movslq 0x8(%rax), %rsi
callq 0xc4f0
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x881e
leaq -0x60(%rbp), %rdi
callq 0xc770
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
incl %eax
movl %eax, -0x58(%rbp)
movq -0x30(%rbp), %rsi
addq $0x10, %rsi
leaq -0x50(%rbp), %rdi
callq 0xca50
jmp 0x87e6
movq -0x88(%rbp), %rsi
movq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x91b0
jmp 0x87fc
leaq -0x60(%rbp), %rdi
callq 0xc5d0
jmp 0x881e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xc5d0
jmp 0x8873
jmp 0x8820
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x86f1
movq -0x88(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x8a60
jmp 0x8840
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x8866
jmp 0x885a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x8873
movq -0x88(%rbp), %rdi
callq 0xc5f0
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0xc5f0
movq -0x68(%rbp), %rdi
callq 0x34e0
nopl (%rax,%rax)