LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: antoniogarro[P]Hara/tree.cpp
// Function: Tree::print(Node*, int, int) const
void Tree::print(Node *node, int threshold, int depth) const
{
  for (int i = 0; i < depth; i++) std::cerr << "  ";
  std::cerr << "|->";
  node->print(goban->get_size());
  
  Node *childs[MAXSIZE2] = {0};
  int len = 0;
  for (Node *child = node->get_child(); child; child=child->get_sibling()) {
    if (child->get_visits() >= threshold) childs[len++] = child;
  }

  while (true) {
    int best = -1, visits = 0;
    for (int i = 0; i < len; i++) {
      if (childs[i] && childs[i]->get_visits() > visits) {
        best = i;
        visits = childs[best]->get_visits();
      }
    }
    if (best < 0) break;
    if (childs[best]->get_move()) print(childs[best], threshold, depth+1);
    childs[best] = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xba0, %rsp            # imm = 0xBA0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb98(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x12d11
movq 0x82f6(%rip), %rdi      # 0x1aff0
leaq 0x1793(%rip), %rsi      # 0x14494
callq 0x3270
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12ceb
movq 0x82d8(%rip), %rdi      # 0x1aff0
leaq 0x1af9(%rip), %rsi      # 0x14818
callq 0x3270
movq -0xb98(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0xba0(%rbp)
movq 0x20(%rax), %rdi
callq 0x4530
movq -0xba0(%rbp), %rdi
movl %eax, %esi
callq 0x12240
leaq -0xb70(%rbp), %rdi
xorl %esi, %esi
movl $0xb48, %edx            # imm = 0xB48
callq 0x3120
movl $0x0, -0xb74(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13330
movq %rax, -0xb80(%rbp)
cmpq $0x0, -0xb80(%rbp)
je 0x12dd4
movq -0xb80(%rbp), %rdi
callq 0x4700
cvtsi2sdl -0x14(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jb 0x12dbd
movq -0xb80(%rbp), %rcx
movl -0xb74(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0xb74(%rbp)
cltq
movq %rcx, -0xb70(%rbp,%rax,8)
jmp 0x12dbf
movq -0xb80(%rbp), %rdi
callq 0x13350
movq %rax, -0xb80(%rbp)
jmp 0x12d7a
jmp 0x12dd6
movl $0xffffffff, -0xb84(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0xb88(%rbp)
movl $0x0, -0xb8c(%rbp)
movl -0xb8c(%rbp), %eax
cmpl -0xb74(%rbp), %eax
jge 0x12e73
movslq -0xb8c(%rbp), %rax
cmpq $0x0, -0xb70(%rbp,%rax,8)
je 0x12e60
movslq -0xb8c(%rbp), %rax
movq -0xb70(%rbp,%rax,8), %rdi
callq 0x4700
cvtsi2sdl -0xb88(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x12e60
movl -0xb8c(%rbp), %eax
movl %eax, -0xb84(%rbp)
movslq -0xb84(%rbp), %rax
movq -0xb70(%rbp,%rax,8), %rdi
callq 0x4700
cvttsd2si %xmm0, %eax
movl %eax, -0xb88(%rbp)
jmp 0x12e62
movl -0xb8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb8c(%rbp)
jmp 0x12df4
cmpl $0x0, -0xb84(%rbp)
jge 0x12e7e
jmp 0x12ed3
movslq -0xb84(%rbp), %rax
movq -0xb70(%rbp,%rax,8), %rdi
callq 0x4740
cmpl $0x0, %eax
je 0x12ebb
movq -0xb98(%rbp), %rdi
movslq -0xb84(%rbp), %rax
movq -0xb70(%rbp,%rax,8), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
callq 0x12cc0
movslq -0xb84(%rbp), %rax
movq $0x0, -0xb70(%rbp,%rax,8)
jmp 0x12dd6
addq $0xba0, %rsp            # imm = 0xBA0
popq %rbp
retq
nopl (%rax)
// File: antoniogarro[P]Hara/./amaf.h
// Function: AmafBoard::value(int, int, bool, double) const
double value(int coord, int depth, bool side, double discount) const
  {
    if (coord == 0) return 0.0;
    int val = side ? -board[coord] : board[coord];
    if (val >= depth) {
      return 1.0 - discount*val;
    } else {
      return 0;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x13202
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x13276
testb $0x1, -0x19(%rbp)
je 0x1321a
movq -0x38(%rbp), %rcx
movslq -0x14(%rbp), %rdx
xorl %eax, %eax
subl (%rcx,%rdx,4), %eax
movl %eax, -0x3c(%rbp)
jmp 0x13228
movq -0x38(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x1326e
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0xdbd(%rip), %xmm1      # 0x14020
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x13276
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: antoniogarro[P]Hara/zobrist.cpp
// Function: Zobrist::Zobrist()
Zobrist::Zobrist()
{
  zob_key = 0;
  zob_side = genrand64_int64();
  for(int i = 0; i < MAXSIZE2; i++){
    zob_points [0][i] = genrand64_int64();
    zob_points [1][i] = genrand64_int64();
    zob_ko[i] = genrand64_int64();
  }
  clear_history();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, (%rax)
callq 0x13540
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x169, -0xc(%rbp)      # imm = 0x169
jge 0x1352b
callq 0x13540
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
callq 0x13540
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, 0xb58(%rax,%rcx,8)
callq 0x13540
movq %rax, %rdx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, 0x16a0(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x134d2
movq -0x18(%rbp), %rdi
callq 0x137a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: antoniogarro[P]Hara/zobrist.cpp
// Function: Zobrist::update(int const*, int)
void Zobrist::update(const int *moves, const int moves_len)
{
  bool side = 0;
  reset();
  for(int i = 0; i < moves_len; i++){
    if(moves[i]) zob_key ^= zob_points[side][moves[i]-1];
    side = !side;
  }
  if(side) zob_key ^= zob_side;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x13830
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1396f
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x1395a
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movb -0x15(%rbp), %dl
andb $0x1, %dl
movzbl %dl, %edx
imulq $0xb48, %rdx, %rdx      # imm = 0xB48
addq %rdx, %rcx
movq -0x10(%rbp), %rdx
movslq -0x1c(%rbp), %rsi
movl (%rdx,%rsi,4), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
xorq (%rax), %rcx
movq %rcx, (%rax)
movb -0x15(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x15(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1390b
testb $0x1, -0x15(%rbp)
je 0x13983
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
xorq (%rax), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: zengfenfei[P]codility/src/FrogRiverOne.cpp
// Function: solution(int, std::vector<int, std::allocator<int>>&)
int solution(int X, vector<int> &A) {
	// write your code in C++11 (g++ 4.8.2)
	vector<bool> hasLeaves(X, false);
	int validLeaves = 0;
	for (unsigned int i = 0; i < A.size(); i++) {
		bool has = hasLeaves[A[i] - 1];
		if (!has) {
			hasLeaves[A[i] - 1] = true;
			validLeaves++;
			if (validLeaves == X) {
				return i;
			}
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movslq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x39(%rbp)
leaq -0x3a(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1580
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rcx
leaq -0x38(%rbp), %rdi
leaq -0x39(%rbp), %rdx
callq 0x15a0
jmp 0x129e
leaq -0x3a(%rbp), %rdi
callq 0x1620
movl $0x0, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1640
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x13e9
movq -0x10(%rbp), %rdi
movl -0x54(%rbp), %eax
movl %eax, %esi
callq 0x16c0
movl (%rax), %eax
decl %eax
movslq %eax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x1660
movq %rdx, -0xa8(%rbp)
movq %rax, -0xa0(%rbp)
jmp 0x1309
movq -0xa8(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x60(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x16e0
andb $0x1, %al
movb %al, -0x55(%rbp)
testb $0x1, -0x55(%rbp)
jne 0x13d9
movq -0x10(%rbp), %rdi
movl -0x54(%rbp), %eax
movl %eax, %esi
callq 0x16c0
movl (%rax), %eax
decl %eax
movslq %eax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x1660
movq %rdx, -0xb8(%rbp)
movq %rax, -0xb0(%rbp)
jmp 0x1365
movq -0xb8(%rbp), %rax
movq -0xb0(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq %rax, -0x70(%rbp)
leaq -0x78(%rbp), %rdi
movl $0x1, %esi
callq 0x1710
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x13d7
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x7c(%rbp)
jmp 0x13f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x3a(%rbp), %rdi
callq 0x1620
jmp 0x140c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1760
jmp 0x140c
jmp 0x13d9
jmp 0x13db
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x12b5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x7c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1760
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x1100
nopw %cs:(%rax,%rax)
// File: zengfenfei[P]codility/src/FrogRiverOne.cpp
// Function: main
int main() {
	vector<int> A(8);
	A[0] = 1;
	A[1] = 3;
	A[2] = 1;
	A[3] = 4;
	A[4] = 2;
	A[5] = 3;
	A[6] = 5;
	A[7] = 4;
	cout << solution(5, A) << '\n';	// 6
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1780
movq -0x38(%rbp), %rdx
leaq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x17a0
jmp 0x1449
leaq -0x19(%rbp), %rdi
callq 0x1810
xorl %eax, %eax
movl %eax, %esi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x16c0
movq -0x48(%rbp), %rdi
movl $0x1, (%rax)
movl $0x1, %esi
callq 0x16c0
movq -0x48(%rbp), %rdi
movl $0x3, (%rax)
movl $0x2, %esi
callq 0x16c0
movq -0x48(%rbp), %rdi
movl $0x1, (%rax)
movl $0x3, %esi
callq 0x16c0
movq -0x48(%rbp), %rdi
movl $0x4, (%rax)
movl $0x4, %esi
callq 0x16c0
movq -0x48(%rbp), %rdi
movl $0x2, (%rax)
movl $0x5, %esi
callq 0x16c0
movq -0x48(%rbp), %rdi
movl $0x3, (%rax)
movl $0x6, %esi
callq 0x16c0
movq -0x48(%rbp), %rdi
movl $0x5, (%rax)
movl $0x7, %esi
callq 0x16c0
movq -0x48(%rbp), %rsi
movl $0x4, (%rax)
movl $0x5, %edi
callq 0x1250
movl %eax, -0x3c(%rbp)
jmp 0x1508
movl -0x3c(%rbp), %esi
movq 0x4ac6(%rip), %rdi      # 0x5fd8
callq 0x10f0
movq %rax, -0x50(%rbp)
jmp 0x151d
movq -0x50(%rbp), %rdi
movl $0xa, %esi
callq 0x10d0
jmp 0x152d
leaq -0x18(%rbp), %rdi
callq 0x1830
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x1810
jmp 0x156a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1830
movq -0x28(%rbp), %rdi
callq 0x1100
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kage08[P]RegexLibrary/Resource.cpp
// Function: NFA::NFA(std::vector<char, std::allocator<char>>&, char)
NFA::NFA(vector<char>& alph, char c){
      if(find(alph.begin(),alph.end(),c)==alph.end() && c!='@'){
        cerr<<"Invalid initialization of simple NFA\n";
        exit(0);
      }


      noStates=2;

      Trans=vector<set<pair<char,uLong> > >(noStates,set<pair<char,uLong> >());
      alphabet=alph;
      addTransition(0,1,c);
      acceptStates.insert(1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
addq $0x8, %rdi
movq %rdi, -0xd8(%rbp)
callq 0x5420
movq -0xc8(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0xd0(%rbp)
callq 0x5440
movq -0xc8(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0xc0(%rbp)
callq 0x5460
movq -0x10(%rbp), %rdi
callq 0x5950
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5980
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x11(%rbp), %rdx
callq 0x5900
movq %rax, -0xb8(%rbp)
jmp 0x2785
movq -0xb8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5980
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x58c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xd9(%rbp)
jne 0x27bb
jmp 0x27cb
movsbl -0x11(%rbp), %eax
cmpl $0x40, %eax
setne %al
movb %al, -0xd9(%rbp)
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x27d7
jmp 0x2804
movq 0x17812(%rip), %rdi     # 0x19ff0
leaq 0xe82f(%rip), %rsi      # 0x11014
callq 0x21d0
jmp 0x27ec
xorl %edi, %edi
callq 0x2290
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x295c
movq -0xc8(%rbp), %rax
movq $0x2, (%rax)
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x5480
leaq -0x91(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x54a0
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
movq -0xe8(%rbp), %rcx
leaq -0x60(%rbp), %rdi
callq 0x54c0
jmp 0x2874
movq -0xc8(%rbp), %rdi
addq $0x8, %rdi
leaq -0x60(%rbp), %rsi
movq %rsi, -0x100(%rbp)
callq 0x5540
movq -0x100(%rbp), %rdi
callq 0x5570
leaq -0x91(%rbp), %rdi
callq 0x55d0
leaq -0x90(%rbp), %rdi
callq 0x55f0
movq -0xc8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rdi
callq 0x5610
jmp 0x28c9
movq -0xc8(%rbp), %rdi
movsbl -0x11(%rbp), %ecx
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x2990
jmp 0x28e4
movq -0xc8(%rbp), %rdi
addq $0x20, %rdi
movq $0x1, -0xa0(%rbp)
leaq -0xa0(%rbp), %rsi
callq 0x59b0
movb %dl, -0x109(%rbp)
movq %rax, -0x108(%rbp)
jmp 0x2915
movb -0x109(%rbp), %al
movq -0x108(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
movb %al, -0xa8(%rbp)
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x91(%rbp), %rdi
callq 0x55d0
leaq -0x90(%rbp), %rdi
callq 0x55f0
movq -0xc0(%rbp), %rdi
callq 0x5840
movq -0xd0(%rbp), %rdi
callq 0x58a0
movq -0xd8(%rbp), %rdi
callq 0x5570
movq -0x38(%rbp), %rdi
callq 0x2380
nopl (%rax)
// File: kage08[P]RegexLibrary/Resource.cpp
// Function: Kleeny(NFA&)
NFA Kleeny(NFA& A){
  NFA B=A;
  for(uLong f:B.acceptStates)
    B.addTransition(f,0,'@');
  B.acceptStates.insert(0);
  return B;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5df0
movq -0x68(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5b10
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5b40
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5b70
testb $0x1, %al
jne 0x32d4
jmp 0x3320
leaq -0x28(%rbp), %rdi
callq 0x5ba0
movq -0x68(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x40, %ecx
callq 0x2990
jmp 0x32fc
jmp 0x32fe
leaq -0x28(%rbp), %rdi
callq 0x5dc0
jmp 0x32c1
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x5aa0
jmp 0x3370
movq -0x68(%rbp), %rdi
addq $0x20, %rdi
movq $0x0, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x59b0
movb %dl, -0x79(%rbp)
movq %rax, -0x78(%rbp)
jmp 0x3342
movb -0x79(%rbp), %al
movq -0x78(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3363
movq -0x68(%rbp), %rdi
callq 0x5aa0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2380
nopl (%rax)
// File: kage08[P]RegexLibrary/Resource.cpp
// Function: printNFA(NFA&)
void printNFA(NFA& A){
  cout<<A.noStates<<endl;
  for(char c:A.alphabet)
    cout<<c<<" ";
  cout<<endl;
  for(uLong f: A.acceptStates)
    cout<<f<<" ";
  cout<<endl;
  for(uLong i=0;i<A.noStates;i++){
    for(auto pb: A.Trans[i])
      cout<<i<<" "<<pb.second<<" "<<pb.first<<endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq 0x1637b(%rip), %rdi     # 0x19fc8
callq 0x21c0
movq %rax, %rdi
movq 0x1635c(%rip), %rsi     # 0x19fb8
callq 0x2210
movq -0x8(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5950
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5980
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x61b0
testb $0x1, %al
jne 0x3c9a
jmp 0x3cd2
leaq -0x18(%rbp), %rdi
callq 0x61f0
movb (%rax), %al
movb %al, -0x21(%rbp)
movq 0x16319(%rip), %rdi     # 0x19fc8
movsbl -0x21(%rbp), %esi
callq 0x2280
movq %rax, %rdi
leaq 0xd378(%rip), %rsi      # 0x1103a
callq 0x21d0
leaq -0x18(%rbp), %rdi
callq 0x6210
jmp 0x3c87
movq 0x162ef(%rip), %rdi     # 0x19fc8
movq 0x162d8(%rip), %rsi     # 0x19fb8
callq 0x2210
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5b10
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5b40
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5b70
testb $0x1, %al
jne 0x3d1e
jmp 0x3d58
leaq -0x38(%rbp), %rdi
callq 0x5ba0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movq 0x1628f(%rip), %rdi     # 0x19fc8
callq 0x21c0
movq %rax, %rdi
leaq 0xd2f2(%rip), %rsi      # 0x1103a
callq 0x21d0
leaq -0x38(%rbp), %rdi
callq 0x5dc0
jmp 0x3d0b
movq 0x16269(%rip), %rdi     # 0x19fc8
movq 0x16252(%rip), %rsi     # 0x19fb8
callq 0x2210
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x3e54
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x50(%rbp), %rsi
callq 0x5a00
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x5bc0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x5bf0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5c20
testb $0x1, %al
jne 0x3dc6
jmp 0x3e41
leaq -0x60(%rbp), %rdi
callq 0x5c50
movq (%rax), %rcx
movq %rcx, -0x78(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x50(%rbp), %rsi
movq 0x161df(%rip), %rdi     # 0x19fc8
callq 0x21c0
movq %rax, %rdi
leaq 0xd242(%rip), %rsi      # 0x1103a
callq 0x21d0
movq %rax, %rdi
movq -0x70(%rbp), %rsi
callq 0x21c0
movq %rax, %rdi
leaq 0xd227(%rip), %rsi      # 0x1103a
callq 0x21d0
movq %rax, %rdi
movsbl -0x78(%rbp), %esi
callq 0x2280
movq %rax, %rdi
movq 0x1618a(%rip), %rsi     # 0x19fb8
callq 0x2210
leaq -0x60(%rbp), %rdi
callq 0x5cc0
jmp 0x3db3
jmp 0x3e43
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x3d73
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: kage08[P]RegexLibrary/Resource.cpp
// Function: NFA::acceptString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool NFA::acceptString(string st){
  set<uLong> currStates;
  currStates.insert(0);
  currStates=step(currStates,'@');
  for(char c:st){
    currStates=step(currStates,c);
  }
  for(uLong f: acceptStates)
    if(currStates.find(f)!=currStates.end()) return true;
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rsi, -0x150(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x148(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x5440
movq -0x140(%rbp), %rdi
movq $0x0, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x59b0
movb %dl, -0x131(%rbp)
movq %rax, -0x130(%rbp)
jmp 0x3ebc
movq -0x148(%rbp), %rsi
movb -0x131(%rbp), %al
movq -0x130(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movb %al, -0x68(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0x48(%rbp), %rdx
movl $0x40, %ecx
callq 0x2a40
jmp 0x3eee
leaq -0x48(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x6230
leaq -0xa0(%rbp), %rdi
callq 0x58a0
movq -0x150(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x21a0
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x2110
movq %rax, -0xb8(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x6030
testb $0x1, %al
jne 0x3f57
jmp 0x3fcf
leaq -0xb0(%rbp), %rdi
callq 0x6070
movq -0x148(%rbp), %rsi
movb (%rax), %al
movb %al, -0xb9(%rbp)
movsbl -0xb9(%rbp), %ecx
leaq -0xf0(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x2a40
jmp 0x3f8b
leaq -0x48(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x6230
leaq -0xf0(%rbp), %rdi
callq 0x58a0
leaq -0xb0(%rbp), %rdi
callq 0x6170
jmp 0x3f3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x58a0
jmp 0x40d1
movq -0x148(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rdi
callq 0x5b10
movq %rax, -0x100(%rbp)
movq -0xf8(%rbp), %rdi
callq 0x5b40
movq %rax, -0x108(%rbp)
leaq -0x100(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x5b70
testb $0x1, %al
jne 0x4023
jmp 0x40ac
leaq -0x100(%rbp), %rdi
callq 0x5ba0
movq (%rax), %rax
movq %rax, -0x110(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x5d80
movq %rax, -0x158(%rbp)
jmp 0x4052
movq -0x158(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5b40
movq %rax, -0x120(%rbp)
leaq -0x118(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x5b70
testb $0x1, %al
jne 0x4089
jmp 0x4099
movb $0x1, -0x1(%rbp)
movl $0x1, -0x124(%rbp)
jmp 0x40ba
jmp 0x409b
leaq -0x100(%rbp), %rdi
callq 0x5dc0
jmp 0x4007
movb $0x0, -0x1(%rbp)
movl $0x1, -0x124(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x58a0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2380
nopw (%rax,%rax)
// File: ext[P]promise/sample.cpp
// Function: sample_workload(Promise*)
void* sample_workload(Promise* promise){
	printf("thread starting\n");
	usleep(3000 * 1000);
	printf("thread done\n");
	promise->resolve();
	return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2d4d(%rip), %rdi      # 0x5020
movb $0x0, %al
callq 0x2040
movl $0x2dc6c0, %edi         # imm = 0x2DC6C0
callq 0x2130
leaq 0x2d46(%rip), %rdi      # 0x5031
movb $0x0, %al
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2bf0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ext[P]promise/sample.cpp
// Function: main
int main(int argc, const char* argv[]){
	auto promise = execute(sample_workload).done([](){
		printf("promise done callback\n");
	});
	printf("execute async return\n");

	promise.await();
	printf("promise awaited\n");

	pthread_join(thread, nullptr);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xd0(%rip), %rsi       # 0x22c0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2310
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x51(%rbp), %rsi
callq 0x2480
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x2b30
movq %rax, -0x70(%rbp)
jmp 0x23c1
movq -0x70(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x2820
leaq -0x50(%rbp), %rdi
callq 0x2850
leaq -0x30(%rbp), %rdi
callq 0x2ab0
leaq 0x2c57(%rip), %rdi      # 0x503e
xorl %eax, %eax
callq 0x2040
jmp 0x23f0
leaq -0x20(%rbp), %rdi
callq 0x2f90
jmp 0x23fb
leaq 0x2c52(%rip), %rdi      # 0x5054
xorl %eax, %eax
callq 0x2040
jmp 0x240b
movq 0x5cee(%rip), %rdi      # 0x8100
xorl %eax, %eax
movl %eax, %esi
callq 0x2100
jmp 0x241d
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2ab0
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2850
leaq -0x30(%rbp), %rdi
callq 0x2ab0
jmp 0x246e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2ab0
movq -0x60(%rbp), %rdi
callq 0x2190
nopw (%rax,%rax)
// File: ext[P]promise/promise.cpp
// Function: Promise::always(std::function<void ()>)
Promise& Promise::always(callback func){
	pthread_mutex_lock(&impl->mutex);
	impl->cb_always.push_back(func);
	pthread_mutex_unlock(&impl->mutex);
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x30e0
movq %rax, %rdi
callq 0x2160
movq -0x18(%rbp), %rdi
callq 0x30e0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x38, %rdi
callq 0x3100
movq -0x18(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
callq 0x20e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ext[P]promise/promise.cpp
// Function: Promise::resolve()
void Promise::resolve(){
	if ( impl->state != PENDING ){
		return;
	}

	pthread_mutex_lock(&impl->mutex);
	for ( auto func: impl->cb_done   ) func();
	for ( auto func: impl->cb_always ) func();
	impl->set_state(RESOLVED);
	pthread_mutex_unlock(&impl->mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x30e0
cmpl $0x0, 0x28(%rax)
je 0x2c1a
jmp 0x2d93
movq -0x90(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
callq 0x2160
movq -0x90(%rbp), %rdi
callq 0x30e0
addq $0x50, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3170
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x31d0
testb $0x1, %al
jne 0x2c6f
jmp 0x2cc7
leaq -0x18(%rbp), %rdi
callq 0x3210
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3230
movq -0x98(%rbp), %rdi
callq 0x32e0
jmp 0x2c99
leaq -0x40(%rbp), %rdi
callq 0x2850
leaq -0x18(%rbp), %rdi
callq 0x3320
jmp 0x2c5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2850
jmp 0x2d9c
movq -0x90(%rbp), %rdi
callq 0x30e0
addq $0x38, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3170
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x31a0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x31d0
testb $0x1, %al
jne 0x2d08
jmp 0x2d66
leaq -0x60(%rbp), %rdi
callq 0x3210
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3230
movq -0xa0(%rbp), %rdi
callq 0x32e0
jmp 0x2d35
leaq -0x88(%rbp), %rdi
callq 0x2850
leaq -0x60(%rbp), %rdi
callq 0x3320
jmp 0x2cf5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2850
jmp 0x2d9c
movq -0x90(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
movl $0x2, %esi
callq 0x3340
movq -0x90(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
callq 0x20e0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2190
nopw %cs:(%rax,%rax)
// File: ext[P]promise/promise.cpp
// Function: Promise::reject()
void Promise::reject(){
	if ( state() != PENDING ){
		return;
	}

	pthread_mutex_lock(&impl->mutex);
	for ( auto func: impl->cb_fail   ) func();
	for ( auto func: impl->cb_always ) func();
	impl->set_state(REJECTED);
	pthread_mutex_unlock(&impl->mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x2f70
cmpl $0x0, %eax
je 0x2dd9
jmp 0x2f52
movq -0x90(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
callq 0x2160
movq -0x90(%rbp), %rdi
callq 0x30e0
addq $0x68, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3170
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x31d0
testb $0x1, %al
jne 0x2e2e
jmp 0x2e86
leaq -0x18(%rbp), %rdi
callq 0x3210
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3230
movq -0x98(%rbp), %rdi
callq 0x32e0
jmp 0x2e58
leaq -0x40(%rbp), %rdi
callq 0x2850
leaq -0x18(%rbp), %rdi
callq 0x3320
jmp 0x2e1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2850
jmp 0x2f5b
movq -0x90(%rbp), %rdi
callq 0x30e0
addq $0x38, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3170
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x31a0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x31d0
testb $0x1, %al
jne 0x2ec7
jmp 0x2f25
leaq -0x60(%rbp), %rdi
callq 0x3210
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3230
movq -0xa0(%rbp), %rdi
callq 0x32e0
jmp 0x2ef4
leaq -0x88(%rbp), %rdi
callq 0x2850
leaq -0x60(%rbp), %rdi
callq 0x3320
jmp 0x2eb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2850
jmp 0x2f5b
movq -0x90(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
movl $0x1, %esi
callq 0x3340
movq -0x90(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
callq 0x20e0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2190
nopw %cs:(%rax,%rax)
// File: ext[P]promise/promise.cpp
// Function: Promise::await() const
void Promise::await() const {
	struct pollfd fds[1];
	fds[0].fd = impl->fd[0];
	fds[0].events = POLLRDNORM;

	if ( poll(fds, 1, -1) == -1 ){
		fprintf(stderr, "poll failed: %s\n", strerror(errno));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30e0
movl 0x2c(%rax), %eax
movl %eax, -0x10(%rbp)
movw $0x40, -0xc(%rbp)
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2170
cmpl $-0x1, %eax
jne 0x2ff8
movq 0x5010(%rip), %rax      # 0x7fe0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x2030
movl (%rax), %edi
callq 0x2060
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x208b(%rip), %rsi      # 0x507c
movb $0x0, %al
callq 0x2140
addq $0x20, %rsp
popq %rbp
retq
nop
// File: chrislarson1[P]MVEE/include/utils.hpp
// Function: findIdx(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, double)
int findIdx(Eigen::VectorXd& vec, double val)
{
    for (int i=0; i<vec.rows(); i++)
    {
        if (vec(i) == val) 
        { 
			return i;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ed400
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jge 0x1eff34
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1ef370
movsd (%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
jne 0x1eff27
jp 0x1eff27
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1eff3b
jmp 0x1eff29
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1efee8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chrislarson1[P]MVEE/include/utils.hpp
// Function: toStdVec(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, double (*)(double))
std::vector<double> toStdVec(Eigen::VectorXd& fromX, double (*f)(double))
{
	std::vector<double> toX(fromX.size(), 0.);
	for (int i=0; i<fromX.size(); i++)
	{
		toX[i] = (*f)(fromX(i));
	}
	return toX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dfcf0
movq %rax, -0x50(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1e9d10
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rcx
leaq -0x28(%rbp), %rdx
callq 0x1ead90
jmp 0x1effaf
leaq -0x29(%rbp), %rdi
callq 0x1d5960
movl $0x0, -0x40(%rbp)
movslq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dfcf0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jge 0x1f005b
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x40(%rbp), %rsi
callq 0x1ef370
movq %rax, -0x70(%rbp)
jmp 0x1efff7
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rcx
movsd (%rcx), %xmm0
callq *%rax
movsd %xmm0, -0x80(%rbp)
jmp 0x1f000c
movq -0x58(%rbp), %rdi
movslq -0x40(%rbp), %rsi
callq 0x1df5e0
movsd -0x80(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x1effbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x1d5960
jmp 0x1f007b
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x1e7270
jmp 0x1f007b
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1f006e
movq -0x58(%rbp), %rdi
callq 0x1e7270
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1ebeb0
nopw %cs:(%rax,%rax)
// File: chrislarson1[P]MVEE/include/utils.hpp
// Function: toStdMat(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, double (*)(double))
std::vector<std::vector<double>> toStdMat(Eigen::MatrixXd& fromX, double (*f)(double))
{
	std::vector<std::vector<double>> 
	toX(fromX.rows(), std::vector<double>(fromX.cols(), 0.));
	for (int i=0; i<fromX.rows(); i++)
	{
		for (int j=0; j<fromX.cols(); j++)
		{
			toX[i][j] = (*f)(fromX(i, j));
		}
	}
	return toX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d5c30
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e8d50
movq %rax, -0x70(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1e9d10
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rcx
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x1ead90
jmp 0x1f00ff
leaq -0x55(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1e3470
movq -0x88(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x90(%rbp), %rcx
leaq -0x38(%rbp), %rdx
callq 0x1d7240
jmp 0x1f012c
leaq -0x55(%rbp), %rdi
callq 0x1e2230
leaq -0x38(%rbp), %rdi
callq 0x1e7270
leaq -0x41(%rbp), %rdi
callq 0x1d5960
movl $0x0, -0x5c(%rbp)
movslq -0x5c(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d5c30
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jge 0x1f027d
movl $0x0, -0x60(%rbp)
movslq -0x60(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e8d50
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jge 0x1f026d
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x5c(%rbp), %rsi
movslq -0x60(%rbp), %rdx
callq 0x1e6f60
movq %rax, -0xa8(%rbp)
jmp 0x1f01c8
movq -0xb0(%rbp), %rax
movq -0xa8(%rbp), %rcx
movsd (%rcx), %xmm0
callq *%rax
movsd %xmm0, -0xb8(%rbp)
jmp 0x1f01e6
movq -0x88(%rbp), %rdi
movslq -0x5c(%rbp), %rsi
callq 0x1d0e20
movq %rax, %rdi
movslq -0x60(%rbp), %rsi
callq 0x1df5e0
movsd -0xb8(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x1f017c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1f0248
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x55(%rbp), %rdi
callq 0x1e2230
leaq -0x38(%rbp), %rdi
callq 0x1e7270
leaq -0x41(%rbp), %rdi
callq 0x1d5960
jmp 0x1f02a0
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x1d2ec0
jmp 0x1f02a0
jmp 0x1f026f
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x1f014e
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1f0293
movq -0x88(%rbp), %rdi
callq 0x1d2ec0
movq -0x80(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x1ebeb0
nopl (%rax)
// File: chrislarson1[P]MVEE/src/mvee.cpp
// Function: mvee::Mvee::decompose(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Matrix<double, -1, -1, 0, -1, -1>&)
void Mvee::decompose(MatrixXd& A, VectorXd& s, MatrixXd& U, MatrixXd& V)
{
    JacobiSVD<MatrixXd> SVD(A, ComputeThinU | ComputeThinV);
    s = SVD.singularValues();
    V = SVD.matrixV();
    U = SVD.matrixU();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x248(%rbp), %rdi
movq %rdi, -0x268(%rbp)
movl $0x28, %edx
callq 0x1d8390
movq -0x268(%rbp), %rdi
callq 0x1e5960
movq %rax, -0x260(%rbp)
jmp 0x1f08d0
movq -0x260(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x1e81c0
jmp 0x1f08e2
leaq -0x248(%rbp), %rdi
callq 0x1e9cc0
movq %rax, -0x270(%rbp)
jmp 0x1f08f7
movq -0x270(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x1e1150
jmp 0x1f0909
leaq -0x248(%rbp), %rdi
callq 0x1d5950
movq %rax, -0x278(%rbp)
jmp 0x1f091e
movq -0x278(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x1e1150
jmp 0x1f0930
leaq -0x248(%rbp), %rdi
callq 0x1dcf90
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x1dcf90
movq -0x250(%rbp), %rdi
callq 0x1ebeb0
nop
// File: chrislarson1[P]MVEE/src/mvee.cpp
// Function: mvee::Mvee::compute(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, double, double)
void Mvee::compute(vector<vector<double>>& data, double eps, double lmcoeff)
{
    int rows = data.size();
    int cols = data[0].size();
    MatrixXd D(rows, cols);
    for (int i=0; i<rows; i++)
    {
        for (int j=0; j<cols; j++)
        {
            D(i, j) = data[i][j];
        }
    }
    khachiyan(D, eps, lmcoeff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd6e0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d0e20
movq %rax, %rdi
callq 0x1d8250
movl %eax, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x1e9d90
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1f1781
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x1f1771
movq -0x10(%rbp), %rdi
movslq -0x44(%rbp), %rsi
callq 0x1d0e20
movq %rax, %rdi
movslq -0x48(%rbp), %rsi
callq 0x1df5e0
movsd (%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movslq -0x44(%rbp), %rsi
movslq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x1e6f60
movq %rax, -0x68(%rbp)
jmp 0x1f1742
movq -0x68(%rbp), %rax
movsd -0x70(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x1f1701
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1d5cb0
jmp 0x1f17a9
jmp 0x1f1773
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x1f16ee
movq -0x60(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
leaq -0x40(%rbp), %rsi
callq 0x1d8830
jmp 0x1f179a
leaq -0x40(%rbp), %rdi
callq 0x1d5cb0
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x1ebeb0
nopw %cs:(%rax,%rax)
// File: reedoolang[P]reedoo/lexer.cc
// Function: rdo_is_reserved(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool rdo_is_reserved(string tok) {
  int i;
  for (i = 0; i < 9;i++) {
    if (tok == reserved[i])
      return true;
    else
      return false;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x9, -0x14(%rbp)
jge 0x58ca
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
leaq 0x12b74(%rip), %rsi     # 0x18420
shlq $0x5, %rax
addq %rax, %rsi
callq 0x8e00
testb $0x1, %al
jne 0x58be
jmp 0x58c4
movb $0x1, -0x1(%rbp)
jmp 0x58ce
movb $0x0, -0x1(%rbp)
jmp 0x58ce
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: reedoolang[P]reedoo/variables.cc
// Function: goGETVAR(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string goGETVAR(string varname) {

  if (doVARLOOKUP(varname) == 0) {

    

    return variables[varname];

  } else {

    cout << IO_ERROR << "Variable not yet declared." << endl;
    exit(1);

  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3150
movq -0x48(%rbp), %rdi
callq 0xc760
movl %eax, -0x40(%rbp)
jmp 0xc6ca
leaq -0x30(%rbp), %rdi
callq 0x31d0
movl -0x40(%rbp), %eax
cmpl $0x0, %eax
jne 0xc718
movq -0x60(%rbp), %rsi
leaq 0xbf22(%rip), %rdi      # 0x18608
callq 0xc970
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x3150
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31d0
jmp 0xc753
movq 0xb8a9(%rip), %rdi      # 0x17fc8
leaq 0x690e(%rip), %rsi      # 0x13034
callq 0x3290
movq %rax, %rdi
leaq 0x6c90(%rip), %rsi      # 0x133c5
callq 0x3290
movq %rax, %rdi
movq 0xb86c(%rip), %rsi      # 0x17fb0
callq 0x32e0
movl $0x1, %edi
callq 0x3340
movq -0x38(%rbp), %rdi
callq 0x3460
nopl (%rax)
// File: reedoolang[P]reedoo/variables.cc
// Function: doVARLOOKUP(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int doVARLOOKUP(string var) {

  if (variables[var] == "null") {
    return 2;
  } else if (variables[var] == "") {
    return 1;
  } else {
    return 0;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xbe8e(%rip), %rdi      # 0x18608
callq 0xc970
movq %rax, %rdi
leaq 0x6c57(%rip), %rsi      # 0x133e0
callq 0x4be0
testb $0x1, %al
jne 0xc794
jmp 0xc79d
movl $0x2, -0x4(%rbp)
jmp 0xc7d2
movq -0x18(%rbp), %rsi
leaq 0xbe60(%rip), %rdi      # 0x18608
callq 0xc970
movq %rax, %rdi
leaq 0x69db(%rip), %rsi      # 0x13192
callq 0x4be0
testb $0x1, %al
jne 0xc7c2
jmp 0xc7cb
movl $0x1, -0x4(%rbp)
jmp 0xc7d2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: reedoolang[P]reedoo/variables.cc
// Function: doASSIGN(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 doASSIGN(string varname, string varval) {

  int vnl = 0;
  //cout << rdo_eval(varval.substr(5)) << endl;
  //varname = varname.substr(9);
  vnl = varname.length();
  if (varval.substr(0,4) == "expr") {
    varval = rdo_eval(varval.substr(5));
  }
  variables[varname] = varval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rsi, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x33e0
movq -0xa0(%rbp), %rsi
movl %eax, -0x14(%rbp)
xorl %eax, %eax
movl %eax, %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x4, %ecx
callq 0x32c0
movq -0x98(%rbp), %rdi
leaq 0x67ed(%rip), %rsi      # 0x1302b
callq 0x4be0
movb %al, -0x89(%rbp)
jmp 0xc84b
leaq -0x38(%rbp), %rdi
callq 0x31d0
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0xc863
jmp 0xc8f3
movq -0xa0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movl $0x5, %edx
movq $-0x1, %rcx
callq 0x32c0
movq -0xb0(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0xe160
jmp 0xc89b
movq -0xa0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3350
leaq -0x68(%rbp), %rdi
callq 0x31d0
leaq -0x88(%rbp), %rdi
callq 0x31d0
jmp 0xc8f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31d0
jmp 0xc91e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x31d0
jmp 0xc91e
movq -0xa8(%rbp), %rsi
leaq 0xbd07(%rip), %rdi      # 0x18608
callq 0xc970
movq -0xa0(%rbp), %rsi
movq %rax, %rdi
callq 0x3050
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3460
nopw (%rax,%rax)
// File: reedoolang[P]reedoo/eval.cc
// Function: rdo_ws(char)
bool rdo_ws(char c) {
	if (c != ' ')
		return 0;
	else
		return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
cmpl $0x20, %eax
je 0xdeb9
movb $0x0, -0x1(%rbp)
jmp 0xdebd
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: reedoolang[P]reedoo/eval.cc
// Function: rdo_expr_item_type(char)
char rdo_expr_item_type(char c) {

	switch(c) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '.':
			c = 'n';
			break;
		case '+':
		case '-':
		case '*':
		case '/':
			c = 'o';
			break;
		case '(':
		case ')':
			c = 'b';
			break;
	}

	return c;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
movl %eax, -0x8(%rbp)
addl $-0x28, %eax
subl $0x2, %eax
jb 0xdf2f
jmp 0xdeeb
movl -0x8(%rbp), %eax
addl $-0x2a, %eax
subl $0x2, %eax
jb 0xdf29
jmp 0xdef8
movl -0x8(%rbp), %eax
subl $0x2d, %eax
je 0xdf29
jmp 0xdf02
movl -0x8(%rbp), %eax
subl $0x2e, %eax
je 0xdf23
jmp 0xdf0c
movl -0x8(%rbp), %eax
subl $0x2f, %eax
je 0xdf29
jmp 0xdf16
movl -0x8(%rbp), %eax
addl $-0x30, %eax
subl $0x9, %eax
ja 0xdf33
jmp 0xdf23
movb $0x6e, -0x1(%rbp)
jmp 0xdf33
movb $0x6f, -0x1(%rbp)
jmp 0xdf33
movb $0x62, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
// File: reedoolang[P]reedoo/eval.cc
// Function: rdo_opp_to_string[abi:cxx11](char)
string rdo_opp_to_string(char opp) {

	string o = "";

	switch(opp) {
		case '+':
			o = "+";
			break;
		case '-':
			o = "-";
			break;
		case '/':
			o = "/";
			break;
		case '*':
			o = "*";
			break;
		case '(':
			o = "(";
			break;
		case ')':
			o = ")";
			break;
	}

	return o;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movb $0x0, -0xa(%rbp)
leaq -0xb(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x3470
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x5215(%rip), %rsi      # 0x13192
callq 0x4990
jmp 0xdf84
leaq -0xb(%rbp), %rdi
callq 0x3300
movsbl -0x9(%rbp), %eax
addl $-0x28, %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x7, %eax
ja 0xe063
movq -0x40(%rbp), %rax
leaq 0x543a(%rip), %rcx      # 0x133e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xb(%rbp), %rdi
callq 0x3300
jmp 0xe080
movq -0x30(%rbp), %rdi
leaq 0x5158(%rip), %rsi      # 0x13134
callq 0x33a0
jmp 0xdfe3
jmp 0xe063
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31d0
jmp 0xe080
movq -0x30(%rbp), %rdi
leaq 0x512c(%rip), %rsi      # 0x13136
callq 0x33a0
jmp 0xe011
jmp 0xe063
movq -0x30(%rbp), %rdi
leaq 0x511a(%rip), %rsi      # 0x13138
callq 0x33a0
jmp 0xe025
jmp 0xe063
movq -0x30(%rbp), %rdi
leaq 0x5108(%rip), %rsi      # 0x1313a
callq 0x33a0
jmp 0xe039
jmp 0xe063
movq -0x30(%rbp), %rdi
leaq 0x5145(%rip), %rsi      # 0x1318b
callq 0x33a0
jmp 0xe04d
jmp 0xe063
movq -0x30(%rbp), %rdi
leaq 0x503f(%rip), %rsi      # 0x13099
callq 0x33a0
jmp 0xe061
jmp 0xe063
movb $0x1, -0xa(%rbp)
testb $0x1, -0xa(%rbp)
jne 0xe076
movq -0x30(%rbp), %rdi
callq 0x31d0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3460
nopl (%rax)
// File: reedoolang[P]reedoo/eval.cc
// Function: rdo_is_num(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool rdo_is_num(string is_num) {
	if (is_num == "+" or
		is_num == "-" or
		is_num == "/" or
		is_num == "*" or
		is_num == "(" or
		is_num == ")") {
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x508d(%rip), %rsi      # 0x13134
callq 0x4be0
testb $0x1, %al
jne 0xe116
movq -0x18(%rbp), %rdi
leaq 0x507b(%rip), %rsi      # 0x13136
callq 0x4be0
testb $0x1, %al
jne 0xe116
movq -0x18(%rbp), %rdi
leaq 0x5069(%rip), %rsi      # 0x13138
callq 0x4be0
testb $0x1, %al
jne 0xe116
movq -0x18(%rbp), %rdi
leaq 0x5057(%rip), %rsi      # 0x1313a
callq 0x4be0
testb $0x1, %al
jne 0xe116
movq -0x18(%rbp), %rdi
leaq 0x5094(%rip), %rsi      # 0x1318b
callq 0x4be0
testb $0x1, %al
jne 0xe116
movq -0x18(%rbp), %rdi
leaq 0x4f8e(%rip), %rsi      # 0x13099
callq 0x4be0
testb $0x1, %al
jne 0xe116
jmp 0xe11c
movb $0x0, -0x1(%rbp)
jmp 0xe120
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)