LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tlaloc1313[P]chess-project/Queen.cpp
// Function: Queen::Queen(int, int)
Queen::Queen(int startingSquare, int pieceIsWhite){
  location = startingSquare;
  pieceType = 'q';
  isWhite = pieceIsWhite;
  hasMoved = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
callq 0x53f4
leaq 0x362e(%rip), %rax      # 0x8d20
movq %rax, (%r15)
movl %r14d, 0xc(%r15)
movb $0x71, 0x8(%r15)
testl %ebx, %ebx
setne 0x10(%r15)
movb $0x0, 0x11(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tlaloc1313[P]chess-project/Queen.cpp
// Function: Queen::checkPath(int, bool*)
bool Queen::checkPath(int destination, bool activeArray[64]){
	int dir = direction(destination);
	if (dir%2 == 0) {
		if (checkStraight(destination, activeArray) == -1) {
			return 1;
		}
	} else {
		if (checkDiagonal(destination, activeArray) == -1) {
			return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
callq 0x540c
movq %r15, %rdi
movl %r14d, %esi
movq %rbx, %rdx
testb $0x1, %al
jne 0x5742
callq 0x54e6
jmp 0x5747
callq 0x55ae
cmpl $-0x1, %eax
je 0x5750
xorl %eax, %eax
jmp 0x5752
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tlaloc1313[P]chess-project/Queen.cpp
// Function: Queen::move(int, bool*)
bool Queen::move(int square, bool activeArray[64]){
	int currentLocation = location;
  // Illegal if moving to current position
  if (currentLocation == square) {
    return 0;
  }

  // Move OK if piece is moving to same row or col OR moving diagonally
  // AND path is free
  if (  ((row(currentLocation) == row(square)
        || col(currentLocation) == col(square))
        || (abs(row(square)-row(location)) == abs(col(square)-col(location))))
      && checkPath(square, activeArray)){
    location = square;
    hasMoved = 1;
    return 1;
  }
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0xc(%rdi), %r12d
cmpl %esi, %r12d
je 0x5814
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
movl %r12d, %edi
callq 0x3558
movl %eax, %r13d
movl %r14d, %edi
callq 0x3558
cmpl %eax, %r13d
je 0x57f6
movl %r12d, %edi
callq 0x356a
movl %eax, %r12d
movl %r14d, %edi
callq 0x356a
cmpl %eax, %r12d
je 0x57f6
movl %r14d, %edi
callq 0x3558
movl %eax, %r12d
movl 0xc(%rbx), %edi
callq 0x3558
subl %eax, %r12d
movl %r12d, %r13d
negl %r13d
cmovsl %r12d, %r13d
movl %r14d, %edi
callq 0x356a
movl %eax, %r12d
movl 0xc(%rbx), %edi
callq 0x356a
subl %eax, %r12d
movl %r12d, %eax
negl %eax
cmovsl %r12d, %eax
cmpl %eax, %r13d
jne 0x5814
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq *(%rax)
testb %al, %al
je 0x5814
movl %r14d, 0xc(%rbx)
movb $0x1, 0x11(%rbx)
movb $0x1, %al
jmp 0x5816
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tlaloc1313[P]chess-project/Rook.cpp
// Function: Rook::Rook(int, int)
Rook::Rook(int startingSquare, int pieceIsWhite){
  location = startingSquare;
  pieceType = 'r';
  isWhite = pieceIsWhite;
  hasMoved = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
callq 0x53f4
leaq 0x3506(%rip), %rax      # 0x8d70
movq %rax, (%r15)
movl %r14d, 0xc(%r15)
movb $0x72, 0x8(%r15)
testl %ebx, %ebx
setne 0x10(%r15)
movb $0x0, 0x11(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tlaloc1313[P]chess-project/Rook.cpp
// Function: Rook::move(int, bool*)
bool Rook::move(int square, bool activeArray[64]){
  int currentLocation = location;
  //Illegal if moving to current position
  if (currentLocation == square) {
    return 0;
  }

  // Move is legal if piece is moving to same row or col and path is empty
  if ((row(currentLocation) == row(square) || col(currentLocation) == col(square)) && checkStraight(square, activeArray) == -1) {
    location = square;
    hasMoved = 1;
    return 1;
  }
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0xc(%rdi), %r12d
cmpl %esi, %r12d
je 0x58f1
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
movl %r12d, %edi
callq 0x3558
movl %eax, %r13d
movl %r14d, %edi
callq 0x3558
cmpl %eax, %r13d
je 0x58de
movl %r12d, %edi
callq 0x356a
movl %eax, %r12d
movl %r14d, %edi
callq 0x356a
cmpl %eax, %r12d
jne 0x58f1
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x54e6
cmpl $-0x1, %eax
je 0x5902
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, 0xc(%rbx)
movb $0x1, 0x11(%rbx)
movb $0x1, %al
jmp 0x58f3
// File: /workspace/github_cpp_makefile_star2_O2/tlaloc1313[P]chess-project/Rook.cpp
// Function: Rook::castle(int)
void Rook::castle(int square){
  if (hasMoved == 0){
    location = square;
    hasMoved = 1;
  }
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x11(%rdi)
jne 0x591f
movl %esi, 0xc(%rdi)
movb $0x1, 0x11(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]codecon/src/gloves.cc
// Function: main
int main() {
  auto gm = GloveMatcher{};

  auto line = std::string{};
  getline(std::cin, line);  // ignore number
  while (getline(std::cin, line)) {
    gm.process(line);
  }

  std::cout << gm.matched() << '\n';
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
xorps %xmm0, %xmm0
leaq 0x28(%rsp), %rbx
movaps %xmm0, -0x8(%rbx)
movaps %xmm0, 0x8(%rbx)
movaps %xmm0, 0x18(%rbx)
leaq 0x58(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movaps %xmm0, -0x8(%rax)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2c71(%rip), %rdi      # 0x3fe0
movq %rsp, %rsi
callq 0x1030
movq 0x2c62(%rip), %r14      # 0x3fe0
movq %rsp, %r15
leaq 0x20(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x1030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x13ac
movq %r12, %rdi
movq %r15, %rsi
callq 0x140c
jmp 0x1386
xorl %esi, %esi
cmpq 0x40(%rsp), %rsi
sbbl %esi, %esi
orl 0x20(%rsp), %esi
movq 0x2c10(%rip), %rdi      # 0x3fd0
callq 0x1160
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x10f0
movq %rsp, %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1b1c
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x13f0
movq %rax, %r14
movq %rsp, %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1b1c
movq %r14, %rdi
callq 0x1170
nop
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]codecon/src/gloves.cc
// Function: GloveMatcher::process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto process(const std::string& item) -> void {
    if (isPalindrome(item)) {  // we found a hat!
      return;
    }

    const auto hint = cache_.find(item);
    if (hint != cache_.end()) {
      cache_.erase(hint);
      ++matched_;
    } else {
      cache_.emplace(reverse(item));
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x12ac
testb %al, %al
jne 0x146b
leaq 0x8(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1494
testq %rax, %rax
je 0x144a
movq %r15, %rdi
movq %rax, %rsi
callq 0x15b6
incl (%rbx)
jmp 0x146b
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12df
movq %r15, %rdi
movq %rbx, %rsi
callq 0x16d2
movq %rsp, %rdi
callq 0x1090
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1090
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::Tree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Tree::Tree(
	std::string& input,
	std::string alphabet
	):
	input(input),
	alphabet(alphabet),
	B(input.length() + 1, 0),
	B_i(0),
	ranDFS(false),
	nIntNodes(1),
	nLeaves(0)
{
	input += '$';

	size_t size = sizeof(Node) * input.length() * 2;
	alloc_buf = (Node*)malloc(size);
	bzero(alloc_buf, size);

	alloc_i = 0;

	nextNodeId = input.length();
	root = newNode(assignId(), nullptr, 0, 0);
	lowestIntNode = root;
	root->suffixLink = root;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x21b0
movq %r15, 0x40(%rbx)
andl $0x0, 0x50(%rbx)
xorl %eax, %eax
movb %al, 0x54(%rbx)
movq $0x1, 0x58(%rbx)
leaq 0x68(%rbx), %r12
movq 0x8(%r15), %rsi
incq %rsi
leaq 0x7(%rsp), %rdx
movb %al, (%rdx)
leaq 0x6(%rsp), %rcx
movq %r12, %rdi
callq 0x2c6a
pushq $0x24
popq %rsi
movq %r15, %rdi
callq 0x2110
movq 0x8(%r15), %r14
imulq $0xb0, %r14, %rsi
pushq $0x1
popq %rdi
callq 0x20e0
movq %rax, (%rbx)
leal 0x1(%r14), %ecx
movl %ecx, 0x48(%rbx)
movl $0x1, 0x8(%rbx)
movl %r14d, 0x50(%rax)
movq %rax, 0x10(%rbx)
movq %rax, 0x60(%rbx)
movq %rax, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x2ce8
jmp 0x2458
movq %rax, %rbx
movq %r14, %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::Build()
void Tree::Build() {
	Node *n = root;
	for (int i = 0; i < input.length(); i++) {
		n = insertSuffix(n, i);
	}
	DisplayChildren(root);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
xorl %r14d, %r14d
movq 0x40(%rbx), %rcx
cmpq %r14, 0x8(%rcx)
jbe 0x24d5
movq %rbx, %rdi
movq %rax, %rsi
movl %r14d, %edx
callq 0x24e8
incq %r14
jmp 0x24b8
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x256e
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::insertSuffix(suffixtree::Node*, int)
Node*
Tree::insertSuffix(
	Node *prevLeaf,
	int suffix
	)
{
	Node *u = prevLeaf->parent;

	nLeaves++;

	if (prevLeaf == root) {
		return findPathAndInsert(root, suffix, 0, input.length());

	} else if (u->suffixLink != nullptr) {
		//Case 1: u already existed at the start of iteration (suffix-1).
		Node *v = u->suffixLink;
		//u->stringDepth is equivalent to the length of alpha
		return findPathAndInsert(v, suffix, suffix + v->stringDepth,
			input.length() - suffix - v->stringDepth);

	} else if (u->parent != root) {
		//Case 2A: u was created during iteration (suffix-1), and u' is not root
		Node *uprime = u->parent;
		Node *vprime = uprime->suffixLink;
		//Beta is the edge label between u and uprime.
		int beta = u->beg;
		int betalen = u->len;

		Node *v = nodeHopToV(vprime, beta, betalen);
		u->suffixLink = v;

		return findPathAndInsert(v, suffix, suffix + v->stringDepth,
			input.length() - suffix - v->stringDepth);

	} else {
		//Case 2B: u was created during iteration (suffix-1), and u' is the root
		Node *uprime = u->parent; // root
		Node *vprime = uprime->suffixLink; // also the root
		int betaprime = u->beg + 1; // beta = x betaprime
		int betaprimelen = u->len - 1;

		Node *v = nodeHopToV(vprime, betaprime, betaprimelen);
		u->suffixLink = v;

		return findPathAndInsert(v, suffix, suffix + v->stringDepth,
			input.length() - suffix - v->stringDepth);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %r14
movq (%rsi), %r15
incl 0x5c(%rdi)
movl %edx, %ebx
movq 0x10(%rdi), %rsi
cmpq %rax, %rsi
je 0x2523
movq 0x18(%r15), %rax
testq %rax, %rax
jne 0x254b
movq (%r15), %rcx
movq 0x18(%rcx), %rax
movl 0x48(%r15), %edx
cmpq %rsi, %rcx
je 0x2534
movl 0x4c(%r15), %ecx
jmp 0x253c
movq 0x40(%r14), %rax
movl 0x8(%rax), %r8d
movq %r14, %rdi
movl %ebx, %edx
xorl %ecx, %ecx
jmp 0x2563
incl %edx
movl 0x4c(%r15), %ecx
decl %ecx
movq %r14, %rdi
movq %rax, %rsi
callq 0x285c
movq %rax, 0x18(%r15)
movl 0x54(%rax), %ecx
addl %ebx, %ecx
movq 0x40(%r14), %rdx
movl 0x8(%rdx), %r8d
subl %ecx, %r8d
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x261e
nop
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::DisplayChildren(suffixtree::Node*)
void
Tree::DisplayChildren(
	Node *node
	)
{
	Node *child = node->child;

	while (child != nullptr) {
		std::cout << "Node id: " << child->id << "Edge label: '";
		for (int i = child->beg; i < child->len + child->beg; i++) {
			std::cout << input[i];
		}
		std::cout << "'" << std::endl;

		child = child->sibling;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rbx
movq 0x3a4e(%rip), %r15      # 0x5fd8
leaq 0x1ae3(%rip), %r13      # 0x4074
leaq 0x1ae8(%rip), %rbp      # 0x4080
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x260e
movq %r15, %rdi
leaq 0x1ac0(%rip), %rsi      # 0x406a
callq 0x2140
movl 0x50(%rbx), %esi
movq %rax, %rdi
callq 0x21f0
movq %rax, %rdi
movq %r13, %rsi
callq 0x2140
movl 0x48(%rbx), %eax
movslq %eax, %r12
movslq 0x4c(%rbx), %rcx
cltq
addq %rcx, %rax
cmpq %rax, %r12
jge 0x25f5
movq 0x40(%r14), %rax
movq (%rax), %rax
movsbl (%rax,%r12), %esi
movq %r15, %rdi
callq 0x2170
incq %r12
movl 0x48(%rbx), %eax
jmp 0x25cb
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x20b0
addq $0x10, %rbx
jmp 0x2598
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::findPathAndInsert(suffixtree::Node*, int, int, int)
Node *
Tree::findPathAndInsert(
	Node *node,
	int suffix,
	int beg,
	int len
	)
{
	/*
	printf("= findPathAndInsert: ");
	PrintSegment(beg, len);
	printf(" -> ");
	PrintNodeLabel(node);
	printf("\n");
	*/

	if (len == 0) {
		printf("len is zero. why?\n");
	}

	Node *child = getChildByLabelBeginning(node, input[beg]);

	// No child by that label
	if (child == nullptr) {
		Node *nchild = newNode(suffix, node, beg, len);
		addChildToNode(node, nchild);

		return nchild;
	}

	for (int i = 1; i < len; i++) {
		if (i >= child->len) {
			return findPathAndInsert(child, suffix, beg + i, len - i);
		}
		if (input[beg + i] != input[child->beg + i]) {
			// SPLIT
			Node *mid = breakEdge(child, i);
			//printf("= splitting: ");
			//PrintNodeLabel(mid);
			//printf("\n");
			return findPathAndInsert(mid, suffix, (beg + i), (len - i));
		}
	}

	panic("shouldnt actually happen");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, 0x4(%rsp)
movq %rsi, %r13
movq %rdi, %rbx
testl %ebp, %ebp
jne 0x2649
leaq 0x1b0d(%rip), %rdi      # 0x4151
callq 0x21e0
movq 0x40(%rbx), %rax
movslq %r14d, %r12
movq (%rax), %r15
movsbl (%r15,%r12), %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x270e
testq %rax, %rax
je 0x26b5
movslq %ebp, %rcx
addq %r15, %r12
pushq $0x1
popq %r13
cmpq %rcx, %r13
jge 0x26ed
movslq 0x4c(%rax), %rdx
cmpq %rdx, %r13
jge 0x2697
movb (%r12,%r13), %dl
movslq 0x48(%rax), %rsi
addq %r15, %rsi
cmpb (%r13,%rsi), %dl
jne 0x269c
incq %r13
jmp 0x2672
addl %r13d, %r14d
jmp 0x26ad
addl %r13d, %r14d
movq %rbx, %rdi
movq %rax, %rsi
movl %r13d, %edx
callq 0x27c4
subl %r13d, %ebp
movq %rax, %r13
jmp 0x2639
movq %rbx, %rdi
movl 0x4(%rsp), %esi
movq %r13, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
callq 0x2468
movq %rax, %r14
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2734
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1910(%rip), %rdi      # 0x4004
leaq 0x1929(%rip), %rsi      # 0x4024
pushq $0x57
popq %rdx
xorl %eax, %eax
callq 0x2030
pushq $0x1
popq %rdi
callq 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::addChildToNode(suffixtree::Node*, suffixtree::Node*)
void 
Tree::addChildToNode(
	Node *parent,
	Node *child
	)
{
	Node *cur = parent->child;
	if (cur == nullptr) {
		parent->child = child;
		return;
	}

	char k = input[child->beg];
	if (k == '$') {
		if (cur != nullptr && input[cur->beg] == '$') {
			panic("shouldnt already have child with this label");
		}

		child->sibling = cur;
		parent->child = child;
		return;
	}

	Node *prev = nullptr;
	while(cur != nullptr) {
		if (k < input[cur->beg]) {
			child->sibling = cur;
			if (prev == nullptr) {
				parent->child = child;
			} else {
				prev->sibling = child;
			}
			return;
		}

		prev = cur;
		cur = cur->sibling;
	}
	prev->sibling = child;
}

// Assembly:
pushq %rax
movq 0x8(%rsi), %rax
addq $0x8, %rsi
testq %rax, %rax
je 0x279d
movq 0x40(%rdi), %rcx
movslq 0x48(%rdx), %rdi
movq (%rcx), %rcx
movb (%rcx,%rdi), %dil
cmpb $0x24, %dil
jne 0x2767
movslq 0x48(%rax), %rdi
cmpb $0x24, (%rcx,%rdi)
je 0x27a2
movq %rax, 0x10(%rdx)
jmp 0x279d
xorl %r8d, %r8d
testq %rax, %rax
je 0x2785
movq %rax, %r9
movslq 0x48(%rax), %rax
cmpb (%rcx,%rax), %dil
jl 0x278e
movq 0x10(%r9), %rax
movq %r9, %r8
jmp 0x276a
addq $0x10, %r8
movq %r8, %rsi
jmp 0x279d
movq %r9, 0x10(%rdx)
leaq 0x10(%r8), %rax
testq %r8, %r8
cmovneq %rax, %rsi
movq %rdx, (%rsi)
popq %rax
retq
leaq 0x188e(%rip), %rdi      # 0x4037
leaq 0x1874(%rip), %rsi      # 0x4024
movl $0x101, %edx            # imm = 0x101
xorl %eax, %eax
callq 0x2030
pushq $0x1
popq %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::breakEdge(suffixtree::Node*, int)
Node *
Tree::breakEdge(
	Node *n,
	int i
	)
{
	//printf("= breakEdge(%d)\n", i);
	Node *parent = nullptr, *nNode = nullptr;

	parent = n->parent;

	//Make new node
	nNode = newNode(assignId(), parent, n->beg, i);
	//Remove n from parent's children, replace with new node.
	replaceChild(parent, nNode);

	n->sibling = nullptr;

	//Insert n under new node
	addChildToNode(nNode, n);

	//Alter n
	n->beg = n->beg + i;
	n->parent = nNode;
	n->len = n->len - i;

	//We have a new internal node
	nIntNodes++;
	if (lowestIntNode == nullptr ||
		nNode->stringDepth > lowestIntNode->stringDepth) {
		lowestIntNode = nNode;
	}

	return nNode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r12
movl 0x48(%rdi), %esi
leal 0x1(%rsi), %eax
movl %eax, 0x48(%rdi)
movl 0x48(%r14), %ecx
movq %r12, %rdx
movl %ebp, %r8d
callq 0x2468
movq %rax, %r15
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x28d4
andq $0x0, 0x10(%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2734
addl %ebp, 0x48(%r14)
movq %r15, (%r14)
subl %ebp, 0x4c(%r14)
incl 0x58(%rbx)
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x2833
movl 0x54(%r15), %ecx
cmpl 0x54(%rax), %ecx
jle 0x2837
movq %r15, 0x60(%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::nodeHopToV(suffixtree::Node*, int, int)
Node *
Tree::nodeHopToV(
	Node *start,
	int beta,
	int len
	)
{
	int i = 0, remaining;
	char c;
	Node *n1 = start, *n2;

	if (len == 0)
		return start;

	while (true) {
		remaining = len - i;
		c = input[beta + i];
		n2 = getChildByLabelBeginning(n1, c);


		if (n2->len > remaining) {
			//break edge right before index 'remaining' of the edge.
			return breakEdge(n2, remaining);

		} else if (n2->len == remaining) {
			//Beta is perfectly consumed, we have found V.
			return n2;

		} else {
			//Travel edge, consume part of beta
			i += n2->len;
			n1 = n2;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
testl %ecx, %ecx
je 0x28aa
movl %ecx, %ebx
movl %edx, %r14d
movq %rdi, %r15
movq 0x40(%rdi), %rcx
movq (%rcx), %r12
xorl %r13d, %r13d
movl %ebx, %ebp
subl %r13d, %ebp
leal (%r14,%r13), %ecx
movslq %ecx, %rcx
movsbl (%r12,%rcx), %edx
movq %r15, %rdi
movq %rax, %rsi
callq 0x270e
movl 0x4c(%rax), %ecx
cmpl %ebp, %ecx
jg 0x28b9
addl %ecx, %r13d
cmpl %ebp, %ecx
jne 0x2880
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %rax, %rsi
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x27c4
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::replaceChild(suffixtree::Node*, suffixtree::Node*)
void Tree::replaceChild(Node *parent, Node *node) {
	Node *prev = nullptr;
	Node *cur = parent->child;
	char k = input[node->beg];

	while (cur != nullptr) {
		if (k == input[cur->beg]) {
			node->sibling = cur->sibling;
			if (prev == nullptr) {
				parent->child = node;
			} else {
				prev->sibling = node;
			}
			return;
		}

		prev = cur;
		cur = cur->sibling;
	}
}

// Assembly:
addq $0x8, %rsi
movq 0x40(%rdi), %rax
movslq 0x48(%rdx), %rcx
movq (%rax), %rax
movb (%rax,%rcx), %cl
xorl %r8d, %r8d
movq %rsi, %r9
movq %r8, %rdi
movq (%r9), %r8
testq %r8, %r8
je 0x291a
movslq 0x48(%r8), %r10
leaq 0x10(%r8), %r9
cmpb (%rax,%r10), %cl
jne 0x28ec
movq (%r9), %rax
movq %rax, 0x10(%rdx)
leaq 0x10(%rdi), %rax
testq %rdi, %rdi
cmoveq %rsi, %rax
movq %rdx, (%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::EnumerateNodesDFS()
void
Tree::EnumerateNodesDFS()
{
	printCount = 0;
	recursiveEnumerateNodesDFS(root);
	std::cout << std::endl;
	printCount = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
andl $0x0, 0x4c(%rdi)
movq 0x10(%rdi), %rsi
callq 0x2940
movq 0x36a4(%rip), %rdi      # 0x5fd8
callq 0x20b0
andl $0x0, 0x4c(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::recursiveEnumerateNodesDFS(suffixtree::Node*)
void
Tree::recursiveEnumerateNodesDFS(
	Node *n
	)
{
	//After 10 enumerations, print a newline
	if (printCount == 10) {
		std::cout << std::endl;
		printCount = 0;
	}

	std::cout << n->stringDepth;

	if (printCount != 9)
		std::cout << " ";

	printCount++;
	Node *child = n->child;

	while (child != nullptr) {
		recursiveEnumerateNodesDFS(child);
		child = child->sibling;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xa, 0x4c(%rdi)
jne 0x2961
movq 0x3681(%rip), %rdi      # 0x5fd8
callq 0x20b0
andl $0x0, 0x4c(%r14)
movl 0x54(%rbx), %esi
movq 0x366d(%rip), %rdi      # 0x5fd8
callq 0x21f0
cmpl $0x9, 0x4c(%r14)
jne 0x297c
pushq $0xa
popq %rax
jmp 0x2995
movq 0x3655(%rip), %rdi      # 0x5fd8
leaq 0x16e8(%rip), %rsi      # 0x4072
callq 0x2140
movl 0x4c(%r14), %eax
incl %eax
movl %eax, 0x4c(%r14)
addq $0x8, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x29b6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2940
addq $0x10, %rbx
jmp 0x299d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::recursiveEnumerateBWT(suffixtree::Node*)
void Tree::recursiveEnumerateBWT(
	Node *n
	)
{
	//Must be a leaf node.
	if (n->child == nullptr) {
		if (n->id == 0) {
			B[B_i++] = input[input.length() - 1];
		} else {
			B[B_i++] = input[n->id - 1];
		}
		return;
	}

	Node *child = n->child;
	while (child != nullptr) {
		recursiveEnumerateBWT(child);
		child = child->sibling;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x29e4
testq %r14, %r14
je 0x2a11
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29be
movq 0x10(%r14), %r14
jmp 0x29ce
movslq 0x50(%rsi), %rax
movq 0x40(%rbx), %rcx
testq %rax, %rax
je 0x29f6
addq (%rcx), %rax
jmp 0x29fd
movq (%rcx), %rax
addq 0x8(%rcx), %rax
movb -0x1(%rax), %al
movslq 0x50(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x50(%rbx)
movq 0x68(%rbx), %rdx
movb %al, (%rdx,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::EnumerateBWT()
void Tree::EnumerateBWT()
{
	recursiveEnumerateBWT(root);
	for (auto v : B) {
		std::cout << v << std::endl;
	}
	//printf("NNODES = %d\n", assignId());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
callq 0x29be
movq 0x68(%rbx), %r14
movq 0x70(%rbx), %r15
movq 0x359e(%rip), %rbx      # 0x5fd8
cmpq %r15, %r14
je 0x2a58
movsbl (%r14), %esi
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20b0
incq %r14
jmp 0x2a3a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::printTreeRec(suffixtree::Node*, int)
void Tree::printTreeRec(Node *nd, int depth) {
	writeTabs(depth);
	printf("[");
	PrintNodeLabel(nd);
	printf("]");
	printf("{");
	
	Node *cur = nd->child;
	if (cur != nullptr) {
		printf("\n");
	}

	while(cur != nullptr) {
		printTreeRec(cur, depth + 1);
		cur = cur->sibling;
	}
	if (nd->child != nullptr) {
		writeTabs(depth);
	}
	printf("}\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %edi
callq 0x2af3
pushq $0x5b
popq %rdi
callq 0x21c0
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b16
pushq $0x5d
popq %rdi
callq 0x21c0
pushq $0x7b
popq %rdi
callq 0x21c0
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x2ab5
pushq $0xa
popq %rdi
callq 0x21c0
leal 0x1(%rbx), %ebp
testq %r12, %r12
je 0x2ad1
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x2a6a
movq 0x10(%r12), %r12
jmp 0x2ab8
cmpq $0x0, 0x8(%r14)
je 0x2adf
movl %ebx, %edi
callq 0x2af3
leaq 0x167d(%rip), %rdi      # 0x4163
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/SuffixTree.cpp
// Function: suffixtree::Tree::PrintLongestRepeatSeqInfo()
void
Tree::PrintLongestRepeatSeqInfo() {
	std::cout << "Length of longest repeating sequence: " <<
	  lowestIntNode->stringDepth << std::endl;
	std::cout << "Starting indeces of longest repeating sequence: " << std::endl;

	Node *child = lowestIntNode->child;

	while (child != nullptr) {
		std::cout << child->id << " ";
		child = child->sibling;
	}
	std::cout << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x33f1(%rip), %rbx      # 0x5fd8
leaq 0x14da(%rip), %rsi      # 0x40c8
movq %rbx, %rdi
callq 0x2140
movq 0x60(%r14), %rcx
movl 0x54(%rcx), %esi
movq %rax, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x20b0
leaq 0x14db(%rip), %rsi      # 0x40ef
movq %rbx, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x20b0
movq 0x60(%r14), %r15
addq $0x8, %r15
leaq 0x143f(%rip), %r14      # 0x4072
movq (%r15), %r15
testq %r15, %r15
je 0x2c58
movl 0x50(%r15), %esi
movq %rbx, %rdi
callq 0x21f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2140
addq $0x10, %r15
jmp 0x2c33
movq 0x3379(%rip), %rdi      # 0x5fd8
popq %rbx
popq %r14
popq %r15
jmp 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/io.cpp
// Function: ReadInputFasta(std::basic_ifstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void
ReadInputFasta(
	std::ifstream &in,
	std::string& str,
	std::string& name
	)
{
	int BUFSIZE = 4 * MB;
	char buf[BUFSIZE], _name[MB/2], c = '\0';
	int i = 0;
	memset(buf, 0, BUFSIZE);

	// Skip over '>'
	while (c != '>' && !in.eof()) {
		in >> c;
	}

	in.getline(buf, BUFSIZE);
	// Get unique identifier of sequence, up to first whitespace
	sscanf(buf, "%s", _name);
	// Allocate and copy
	name = std::string(_name);

	i = 0;
	c = '\0';
	memset(buf, 0, BUFSIZE);

	in >> c;
	while (c != '>' && !in.eof()) {
		if (notLineEnd(c)) {
			buf[i++] = c;
		}
		in >> c;
	}
	str = std::string(buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x480038, %rsp         # imm = 0x480038
movq %rdx, %r15
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
leaq 0x6(%rsp), %r12
movb $0x0, (%r12)
leaq 0x80030(%rsp), %rdi
xorl %ebx, %ebx
movl $0x400000, %edx         # imm = 0x400000
xorl %esi, %esi
callq 0x20d0
cmpb $0x3e, %bl
je 0x2ded
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x2ded
movq %r14, %rdi
movq %r12, %rsi
callq 0x21a0
movb 0x6(%rsp), %bl
jmp 0x2dc8
leaq 0x80030(%rsp), %r12
movl $0x400000, %edx         # imm = 0x400000
movq %r14, %rdi
movq %r12, %rsi
callq 0x2060
leaq 0x1359(%rip), %rsi      # 0x4165
xorl %ebx, %ebx
leaq 0x30(%rsp), %r13
movq %r12, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x2130
leaq 0x10(%rsp), %rbp
leaq 0x7(%rsp), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2edc
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2190
movq %rbp, %rdi
callq 0x20a0
leaq 0x6(%rsp), %r15
movb $0x0, (%r15)
movl $0x400000, %edx         # imm = 0x400000
movq %r12, %rdi
xorl %esi, %esi
callq 0x20d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x21a0
movzbl 0x6(%rsp), %eax
cmpl $0x3e, %eax
je 0x2e9b
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%r14,%rcx)
jne 0x2e9b
cmpl $0xa, %eax
je 0x2e60
cmpl $0xd, %eax
je 0x2e60
movl %ebx, %ecx
incl %ebx
movb %al, 0x80030(%rsp,%rcx)
jmp 0x2e60
leaq 0x10(%rsp), %r14
leaq 0x80030(%rsp), %rsi
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x2edc
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2190
movq %r14, %rdi
callq 0x20a0
addq $0x480038, %rsp         # imm = 0x480038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/raemarks[P]SuffixTree/src/main.cpp
// Function: main
int main(int argc, char *argv[])
{
	//TODO: append $ to input string!
	//suffixtree::SuffixTree tree = new suffixtree::SuffixTree(params);

	if (argc < 3) {
		printf("Error, not enough arguments.\n");
		printf("Usage: '%s <input fasta file> {<alphabet>}'\n", argv[0]);
		return 1;
	}

	std::ifstream in(argv[1], std::ifstream::in);
	if (!in.good()) {
		printf("Error: file '%s' not valid.\n", argv[1]);
		return 2;
	}

	std::string name, input;
	ReadInputFasta(in, input, name);

	/*
	std::cout << "Name: " << name << std::endl;
	std::cout << "Input: " << input << std::endl;
	*/

	suffixtree::Tree *t = new suffixtree::Tree(input, "$ACGT");

	t->Build();
	//t->EnumerateNodesDFS();
	t->PrintTreeInfo();
	t->PrintLongestRepeatSeqInfo();
	//t->EnumerateBWT();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %rbx
cmpl $0x2, %edi
jg 0x2fe7
leaq 0x1219(%rip), %rdi      # 0x41e2
callq 0x21e0
movq (%rbx), %rsi
leaq 0x11ba(%rip), %rdi      # 0x4192
xorl %eax, %eax
callq 0x2030
pushq $0x1
popq %rbx
jmp 0x30d3
movq 0x8(%rbx), %rsi
leaq 0x70(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2220
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x90(%rsp,%rax)
je 0x3026
movq 0x8(%rbx), %rsi
leaq 0x11a8(%rip), %rdi      # 0x41bf
xorl %eax, %eax
callq 0x2030
pushq $0x2
popq %rbx
jmp 0x30c9
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x2d8c
movl $0x80, %edi
callq 0x2150
movq %rax, %rbx
leaq 0x116c(%rip), %rsi      # 0x41dc
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2edc
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x23ac
leaq 0x30(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x24aa
movq %rbx, %rdi
callq 0x2b5a
movq %rbx, %rdi
callq 0x2bd8
leaq 0x10(%rsp), %rdi
callq 0x20a0
leaq 0x50(%rsp), %rdi
callq 0x20a0
xorl %ebx, %ebx
leaq 0x70(%rsp), %rdi
callq 0x2040
movl %ebx, %eax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x20a0
jmp 0x30f2
movq %rax, %r14
movl $0x80, %esi
movq %rbx, %rdi
callq 0x2160
jmp 0x3106
jmp 0x3103
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20a0
leaq 0x50(%rsp), %rdi
callq 0x20a0
leaq 0x70(%rsp), %rdi
callq 0x2040
movq %r14, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/billDrett[P]Bulletin-Boards/boardPost.cpp
// Function: BoardPost::BoardPost(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
BoardPost::BoardPost(std::string BP2S, std::string S2BP)
{//anoigoume ta pipes
    if((pipeBoardPost2Server = open(BP2S.c_str(), O_WRONLY)) < 0)
    {
        perror("fifo BP2S not found");
    }

    if((pipeServer2BoardPost = open(S2BP.c_str(), O_RDWR)) < 0)
    {
        perror("fifo S2BP not found");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
pushq $0x1
popq %rsi
xorl %eax, %eax
callq 0x2120
movl %eax, (%rbx)
testl %eax, %eax
js 0x28a5
movq (%r14), %rdi
pushq $0x2
popq %rsi
xorl %eax, %eax
callq 0x2120
movl %eax, 0x4(%rbx)
testl %eax, %eax
js 0x28b3
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x178f(%rip), %rdi      # 0x403b
callq 0x2130
jmp 0x288c
leaq 0x1795(%rip), %rdi      # 0x404f
popq %rbx
popq %r14
popq %rbp
jmp 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O2/billDrett[P]Bulletin-Boards/boardPost.cpp
// Function: BoardPost::sendMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void BoardPost::sendMessage(string message, int Id)
{
    int nwrite;
    char convert[24];
    string name;
    if((nwrite = write(pipeBoardPost2Server, "<Message><start>", 16))== -1) //eisagwgika tag gia message
    {
        perror("Cant write to pipe BP2S");
    }

    sprintf(convert, "%d", Id); //metatrepw to Id se string
    name = "*";
    name.append(convert); //stelnw to chanel mesa se *ID*
    name.append("*");

    if((nwrite = write(pipeBoardPost2Server, name.c_str(), name.size()))== -1) //grafw to chanelID
    {
        perror("Cant write to pipe BP2S");
    }

    if((nwrite = write(pipeBoardPost2Server, message.c_str(), message.size()))== -1) // grafw to message
    {
        perror("Cant write to pipe BP2S");
    }

    if((nwrite = write(pipeBoardPost2Server, "<end><Message>", 14))== -1) //telos message tags
    {
        perror("Cant write to pipe BP2S");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %r15d
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, (%rax)
movl (%rdi), %edi
leaq 0x1507(%rip), %rsi      # 0x4096
pushq $0x10
popq %rdx
callq 0x2090
cmpl $-0x1, %eax
je 0x2c33
leaq 0x1518(%rip), %rsi      # 0x40bf
leaq -0x50(%rbp), %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x2030
leaq 0x1506(%rip), %rsi      # 0x40c2
leaq -0x38(%rbp), %rdi
callq 0x2260
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2250
leaq 0x14e9(%rip), %rsi      # 0x40c2
leaq -0x38(%rbp), %rdi
callq 0x2250
movl (%rbx), %edi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2090
cmpl $-0x1, %eax
je 0x2c44
movl (%rbx), %edi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x2090
cmpl $-0x1, %eax
je 0x2c52
movl (%rbx), %edi
leaq 0x14b2(%rip), %rsi      # 0x40c4
pushq $0xe
popq %rdx
callq 0x2090
cmpl $-0x1, %eax
je 0x2c60
leaq -0x38(%rbp), %rdi
callq 0x20c0
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x146d(%rip), %rdi      # 0x40a7
callq 0x2130
jmp 0x2ba0
leaq 0x145c(%rip), %rdi      # 0x40a7
callq 0x2130
jmp 0x2bf6
leaq 0x144e(%rip), %rdi      # 0x40a7
callq 0x2130
jmp 0x2c09
leaq 0x1440(%rip), %rdi      # 0x40a7
callq 0x2130
jmp 0x2c1f
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/ef-gy[P]libefgy/src/test-case/range.cpp
// Function: testRange(std::ostream&)
bool testRange(std::ostream &log) {
  std::array<int, 5> a5{0, 1, 2, 3, 4};
  std::array<int, 5> b5{1000, 1001, 1002, 1003, 1004};
  std::array<int, 8> a8n{49, 48, 47, 46, 45, 44, 43, 42};

  for (int i : range<int>(0, 4)) {
    std::cerr << i << "\n";
  }

  std::array<int, 8> a1{42, 43, 44, 45, 46, 47, 48, 49};
  std::size_t p = 0;

  for (int i : range<int, 8>(42)) {
    if (i != a1[p]) {
      log << "range<int, 8>(42) did not produce the expected results.\n";
      return false;
    }

    p++;
  }

  if (!std::equal(a1.begin(), a1.end(), range<int, 8>(42).begin())) {
    log << "range iterator did not produce the expected results.\n";
    return false;
  }

  std::array<int, 8> a2{49, 48, 47, 46, 45, 44, 43, 42};

  if (!std::equal(a2.begin(), a2.end(), range<int, 8>(49, 42).begin())) {
    log << "range iterator did not produce the expected results.\n";
    return false;
  }

  if (!std::equal(a2.begin(), a2.end(), range<int>(49, 42, 8, true).begin())) {
    log << "range iterator did not produce the expected results.\n";
    return false;
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movups 0xe281(%rip), %xmm0     # 0x12b40
movaps %xmm0, 0x10(%rsp)
movups 0xe265(%rip), %xmm0     # 0x12b30
movaps %xmm0, (%rsp)
xorl %eax, %eax
cmpq $0x8, %rax
je 0x48ef
leaq 0x1(%rax), %rcx
leal 0x29(%rcx), %edx
cmpl (%rsp,%rax,4), %edx
movq %rcx, %rax
je 0x48d1
leaq 0xd82d(%rip), %rsi      # 0x1211a
jmp 0x496a
leaq 0x20(%rsp), %rsi
movq %rsp, %rdi
movabsq $0x10000002a, %rdx      # imm = 0x10000002A
xorl %ecx, %ecx
callq 0x11410
testb %al, %al
je 0x4963
movabsq $-0xffffffcf, %r14      # imm = 0xFFFFFFFF00000031
movups 0xe243(%rip), %xmm0     # 0x12b60
leaq 0x40(%rsp), %r15
movaps %xmm0, -0x10(%r15)
movups 0xe222(%rip), %xmm0     # 0x12b50
movaps %xmm0, -0x20(%r15)
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x11410
testb %al, %al
je 0x4963
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x11410
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x4974
leaq 0xd7e9(%rip), %rsi      # 0x12153
movq %rbx, %rdi
callq 0x4260
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/examples/named-parameters-ex01.cxx
// Function: main
int main() {
    using namespace cxon::json;
    std::string json;
        cxon::to_bytes(json, 3.1415926, fp_precision::set<3>()); // floating-point precision
    assert(json == "3.14");
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movabsq $0x400921fb4d12d84a, %rax # imm = 0x400921FB4D12D84A
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rcx
callq 0x12be
leaq 0xda5(%rip), %rsi       # 0x2004
leaq 0x10(%rsp), %rdi
callq 0x12b1
testb %al, %al
je 0x127f
leaq 0x10(%rsp), %rdi
callq 0x1070
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
retq
leaq 0xd83(%rip), %rdi       # 0x2009
leaq 0xd8b(%rip), %rsi       # 0x2018
leaq 0xd9e(%rip), %rcx       # 0x2032
pushq $0xa
popq %rdx
callq 0x10b0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/killwing[P]underscore/test.cpp
// Function: main
int main() {
    test_each();
    test_map();
    test_reduce();
    test_reduceRight();
    test_find();
    test_filter();
    test_reject();
    test_every();
    test_some();
    test_contains();
    test_invoke();
    test_pluck();
    test_max();
    test_min();
    test_sortBy();
    test_groupBy();
    test_countBy();
    test_shuffle();
    test_toArray();
    test_size();

    cout << "All tests passed." << endl;
    return 0;
}

// Assembly:
pushq %rax
callq 0x250e
callq 0x43d4
callq 0x76b1
callq 0x9f75
callq 0xbdf0
callq 0xd1f3
callq 0xeee4
callq 0x10bd5
callq 0x11ffc
callq 0x133cd
callq 0x1475e
callq 0x15281
callq 0x15ca7
callq 0x16fe9
callq 0x18324
callq 0x18eb7
callq 0x1b9cb
callq 0x1db07
callq 0x1e204
callq 0x20115
movq 0x1ee55(%rip), %rdi     # 0x3ffd8
leaq 0xe3fb(%rip), %rsi      # 0x2f585
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/killwing[P]underscore/./underscore.h
// Function: std::enable_if<!std::is_void<decltype(*std::begin(fp).*fp0(fp1...))>::value, std::deque<std::decay<decltype(*std::begin(fp).*fp0(fp1...))>::type>>::type _::invoke<std::deque, std::deque<Data, std::allocator<Data>>, int (Data::*)() const>(std::deque<Data, std::allocator<Data>>&, int (Data::*)() const)
auto
invoke(Collection& obj, Function method, Argument&&... args)
    -> typename std::enable_if<!std::is_void<decltype(((*std::begin(obj)).*method)(args...))>::value,
       RetCollection<typename std::decay<decltype(((*std::begin(obj)).*method)(args...))>::type>>::type {

    using R = typename std::decay<decltype(((*std::begin(obj)).*method)(args...))>::type;
    RetCollection<R> result;
    for (auto& i : obj) {
        util::add(result, (i.*method)(std::forward<Argument>(args)...));
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x2959e
movq 0x10(%rbp), %r13
movq 0x20(%rbp), %r12
movq 0x28(%rbp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rbp), %rbp
cmpq %rbp, %r13
je 0x22de1
leaq (%r14,%r13), %rdi
movq %r15, %rax
testb $0x1, %r15b
je 0x22daa
movq (%rdi), %rax
movq -0x1(%rax,%r15), %rax
callq *%rax
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
leaq 0xc(%rsp), %rsi
callq 0x2a3be
addq $0x4, %r13
cmpq %r12, %r13
jne 0x22d90
movq 0x10(%rsp), %rax
movq 0x8(%rax), %r13
addq $0x8, %rax
movq %rax, 0x10(%rsp)
leaq 0x200(%r13), %r12
jmp 0x22d90
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x24afc
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/killwing[P]underscore/./underscore.h
// Function: std::deque<std::decay<decltype(*std::begin(fp).*fp0)>::type> _::pluck<std::deque, std::deque<Data, std::allocator<Data>>, int Data::*>(std::deque<Data, std::allocator<Data>> const&, int Data::*)
auto
pluck(const Collection& obj, Function member)
    -> RetCollection<typename std::decay<decltype((*std::begin(obj)).*member)>::type> {

    using R = typename std::decay<decltype((*std::begin(obj)).*member)>::type;
    RetCollection<R> result;
    for (auto& i : obj) {
        util::add(result, i.*member);
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2959e
movq 0x10(%r15), %r12
movq 0x20(%r15), %rbp
movq 0x28(%r15), %r13
movq 0x30(%r15), %r15
cmpq %r15, %r12
je 0x23400
leaq (%r12,%r14), %rsi
movq %rbx, %rdi
callq 0x295bc
addq $0x4, %r12
cmpq %rbp, %r12
jne 0x233d4
movq 0x8(%r13), %r12
addq $0x8, %r13
leaq 0x200(%r12), %rbp
jmp 0x233d4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x24afc
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/killwing[P]underscore/./underscore.h
// Function: std::deque<int, std::allocator<int>> _::shuffle<std::deque<int, std::allocator<int>>>(std::deque<int, std::allocator<int>> const&)
Collection
shuffle(const Collection& obj) {
    Collection result = obj;
    std::random_device rd;
    std::shuffle(std::begin(result), std::end(result), std::mt19937(rd()));
    return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x2758, %rsp           # imm = 0x2758
movq %rdi, %rbx
callq 0x2b9e2
leaq 0x48(%rsp), %rdi
callq 0x2d50a
movups 0x10(%rbx), %xmm0
movaps %xmm0, 0x20(%rsp)
movups 0x20(%rbx), %xmm0
movaps %xmm0, 0x30(%rsp)
movups 0x30(%rbx), %xmm0
movaps %xmm0, (%rsp)
movups 0x40(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2270
movl %eax, %esi
leaq 0x13d0(%rsp), %rdi
callq 0x2d914
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
leaq 0x13d0(%rsp), %rdx
callq 0x2db8e
leaq 0x48(%rsp), %rdi
callq 0x2d68c
movq %rbx, %rax
addq $0x2758, %rsp           # imm = 0x2758
popq %rbx
popq %r14
retq
movq %rax, %r14
jmp 0x23bba
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x2d68c
movq %rbx, %rdi
callq 0x24afc
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/killwing[P]underscore/./underscore.h
// Function: std::enable_if<!util::HasSize<std::forward_list<int, std::allocator<int>>>::value, unsigned long>::type _::size<std::forward_list<int, std::allocator<int>>>(std::forward_list<int, std::allocator<int>> const&)
typename std::enable_if<!util::HasSize<Collection>::value, size_t>::type
size(const Collection& obj) {
    size_t s = 0;
    for (auto& _ : obj) {
        ++s;
    }
    return s;
}

// Assembly:
pushq $-0x1
popq %rax
movq (%rdi), %rdi
incq %rax
testq %rdi, %rdi
jne 0x23f66
retq
// File: /workspace/github_cpp_makefile_star2_O2/killwing[P]underscore/./underscore.h
// Function: std::enable_if<HasInsertAfter<std::forward_list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::value, void>::type _::util::add<std::forward_list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::forward_list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&)
typename std::enable_if<HasInsertAfter<T>::value, void>::type
add(T& c, U&& v) {
    // get to the end of the list, which is O(N) and not fast at all
    auto before_end = c.before_begin();
    for (auto& _ : c) {
        ++before_end;
    }
    c.insert_after(before_end, std::forward<U>(v));
}

// Assembly:
movq %rsi, %rdx
movq %rdi, %rax
movq %rdi, %rsi
movq (%rax), %rax
testq %rax, %rax
je 0x27fa6
movq (%rsi), %rsi
jmp 0x27f94
nop
// File: /workspace/github_cpp_makefile_star2_O2/stevedonovan[P]outstreams/testout.cpp
// Function: writing_to_file()
int writing_to_file() {
    outs("*writing to file")();
    double x = 1.1, y = 2.0, z = 2.8;
    Writer("test.txt").sep(',')(x)(y)(z)();
    return system("cat test.txt");
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x4a9e(%rip), %rdi      # 0x7140
leaq 0x19e0(%rip), %rsi      # 0x4089
xorl %edx, %edx
callq 0x29e8
movq %rax, %rdi
callq 0x32ee
leaq 0x19e1(%rip), %rsi      # 0x40a0
leaq 0x19d4(%rip), %rdx      # 0x409a
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x31ea
pushq $0x2c
popq %rsi
movq %rbx, %rdi
callq 0x32ac
movsd 0x1922(%rip), %xmm0     # 0x4008
movq %rax, %rdi
xorl %esi, %esi
callq 0x2bdc
movsd 0x1918(%rip), %xmm0     # 0x4010
movq %rax, %rdi
xorl %esi, %esi
callq 0x2bdc
movsd 0x190e(%rip), %xmm0     # 0x4018
movq %rax, %rdi
xorl %esi, %esi
callq 0x2bdc
movq %rax, %rdi
callq 0x32ee
leaq 0x8(%rsp), %rdi
callq 0x34a2
leaq 0x196f(%rip), %rdi      # 0x409c
callq 0x2110
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x34a2
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/stevedonovan[P]outstreams/testout.cpp
// Function: building_strings()
void building_strings() {
    outs("*building strings")();
    StrWriter sw(' ');
    sw(42)("and")(3.4);

    outs(sw.str())();
}

// Assembly:
pushq %rbx
subq $0x60, %rsp
leaq 0x49e7(%rip), %rdi      # 0x7140
leaq 0x1949(%rip), %rsi      # 0x40a9
xorl %edx, %edx
callq 0x29e8
movq %rax, %rdi
callq 0x32ee
leaq 0x28(%rsp), %rbx
pushq $0x20
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3352
pushq $0x2a
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2bee
leaq 0x1926(%rip), %rsi      # 0x40bb
movq %rax, %rdi
xorl %edx, %edx
callq 0x29e8
movsd 0x1879(%rip), %xmm0     # 0x4020
movq %rax, %rdi
xorl %esi, %esi
callq 0x2bdc
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x21c0
movq 0x8(%rsp), %rsi
leaq 0x4974(%rip), %rdi      # 0x7140
xorl %edx, %edx
callq 0x29e8
movq %rax, %rdi
callq 0x32ee
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x28(%rsp), %rdi
callq 0x2bfe
addq $0x60, %rsp
popq %rbx
retq
jmp 0x2806
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
jmp 0x2809
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2bfe
movq %rbx, %rdi
callq 0x21f0