LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: MatthewZMD[P]TetrisDual/window.cc
// Function: Xwindow::fillPolygon(int, int, int, int, int, int)
void Xwindow::fillPolygon(int x, int y, int vertices, int side, int rotate, int colour){
	XPoint* point = new XPoint[vertices];

	point[0] = XPoint{(short int)x, (short int)y};

	double angle = rotate + pi/2;

	for ( int i = 1; i < vertices; ++i ){
		short int X = side * sin(angle);
		short int Y = side * cos(angle);
		point[i] = XPoint{X,Y};
		angle += 2*pi - pi* 2/vertices;
	}

	XSetForeground(d, gc, colours[colour]);
	XFillPolygon(d, w, gc, point, vertices, Convex, CoordModePrevious);
	XSetForeground(d, gc, colours[Black]);

	delete[] point;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movslq -0x14(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6030
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movw %ax, -0x2c(%rbp)
movl -0x10(%rbp), %eax
movw %ax, -0x2a(%rbp)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
cvtsi2sdl -0x1c(%rbp), %xmm0
movsd 0x18293(%rip), %xmm1    # 0x443b8
movsd 0x1953(%rip), %xmm2     # 0x2da80
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x1, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2c213
cvtsi2sdl -0x18(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x6080
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movw %ax, -0x3e(%rbp)
cvtsi2sdl -0x18(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x6680
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movw %ax, -0x40(%rbp)
movw -0x3e(%rbp), %ax
movw %ax, -0x44(%rbp)
movw -0x40(%rbp), %ax
movw %ax, -0x42(%rbp)
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl -0x44(%rbp), %edx
movl %edx, (%rax,%rcx,4)
movsd 0x181f5(%rip), %xmm0    # 0x443b8
movsd 0x18b5(%rip), %xmm1     # 0x2da80
mulsd 0x181e5(%rip), %xmm1    # 0x443b8
cvtsi2sdl -0x14(%rbp), %xmm2
divsd %xmm2, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2c141
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq 0x18(%rax), %rsi
movslq 0x10(%rbp), %rcx
movq 0x20(%rax,%rcx,8), %rdx
callq 0x6130
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq 0x18(%rax), %rdx
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %r8d
movl $0x2, %r9d
movl $0x1, (%rsp)
callq 0x6670
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq 0x18(%rax), %rsi
movq 0x28(%rax), %rdx
callq 0x6130
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x2c280
movq -0x68(%rbp), %rdi
callq 0x64a0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MatthewZMD[P]TetrisDual/window.cc
// Function: Xwindow::printMessage(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, XFontStruct&)
void Xwindow::printMessage(int x, int y, const string& msg, int colour, XFontStruct& f){
  XSetForeground(d, gc, colours[colour]);
  XTextItem ti;
  ti.chars = const_cast<char*>(msg.c_str());
  ti.nchars = msg.length();
  ti.delta = 0;
  ti.font = f.fid;
  XDrawText(d, w, gc, x, y, &ti, 1);
  XSetForeground(d, gc, colours[Black]);
  XFlush(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rax), %rdi
movq 0x18(%rax), %rsi
movslq -0x1c(%rbp), %rcx
movq 0x20(%rax,%rcx,8), %rdx
callq 0x6130
movq -0x18(%rbp), %rdi
callq 0x6170
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6560
movq %rax, %rcx
movq -0x48(%rbp), %rax
movl %ecx, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq 0x18(%rax), %rdx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
leaq -0x40(%rbp), %r9
movl $0x1, (%rsp)
callq 0x64f0
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movq 0x18(%rax), %rsi
movq 0x28(%rax), %rdx
callq 0x6130
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x6590
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MatthewZMD[P]TetrisDual/window.cc
// Function: Xwindow::drawStringFont(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Xwindow::drawStringFont(int x, int y, string msg, string font, int colour) {
  XFontStruct * f = XLoadQueryFont(d, font.c_str());
  
	if ( f == nullptr ){
		f = XLoadQueryFont(d, "6x13");
	}

	printMessage(x, y, msg, colour, *f);
	delete f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %r8, -0x50(%rbp)
movq %rdi, %rax
movq -0x50(%rbp), %rdi
movq %rcx, -0x48(%rbp)
movq %rax, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x6170
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x6650
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2c62f
movq -0x40(%rbp), %rax
movq (%rax), %rdi
leaq 0x1496(%rip), %rsi      # 0x2dabc
callq 0x6650
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x24(%rbp), %r8d
movq -0x30(%rbp), %r9
callq 0x2c500
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x2c666
movq -0x58(%rbp), %rdi
movl $0x60, %esi
callq 0x6370
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: MatthewZMD[P]TetrisDual/window.cc
// Function: Xwindow::drawBigString(int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Xwindow::drawBigString(int x, int y, string msg, int colour) {
  // Font f = XLoadFont(d, "-*-helvetica-bold-r-normal--*-240-*-*-*-*-*");
  ostringstream name;
  name << "-*-helvetica-bold-r-*-*-*-240-" << width/5 << "-" << height/5 << "-*-*-*-*";

	drawStringFont(x, y, msg, name.str(), colour);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rcx, -0x208(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x200(%rbp)
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x64c0
movq -0x1f8(%rbp), %rdi
leaq 0x1401(%rip), %rsi      # 0x2dac1
callq 0x6350
movq %rax, -0x1f0(%rbp)
jmp 0x2c6ce
movq -0x1f0(%rbp), %rdi
movq -0x200(%rbp), %rax
movslq 0x78(%rax), %rax
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x21, %rcx
movl %ecx, %esi
addl %eax, %esi
callq 0x6620
movq %rax, -0x210(%rbp)
jmp 0x2c704
movq -0x210(%rbp), %rdi
leaq 0x13cc(%rip), %rsi      # 0x2dade
callq 0x6350
movq %rax, -0x218(%rbp)
jmp 0x2c720
movq -0x218(%rbp), %rdi
movq -0x200(%rbp), %rax
movslq 0x7c(%rax), %rax
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rax
shrq $0x3f, %rax
sarq $0x21, %rcx
movl %ecx, %esi
addl %eax, %esi
callq 0x6620
movq %rax, -0x220(%rbp)
jmp 0x2c756
movq -0x220(%rbp), %rdi
leaq 0x134f(%rip), %rsi      # 0x2dab3
callq 0x6350
jmp 0x2c76b
movq -0x208(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, -0x228(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x224(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x6180
jmp 0x2c792
leaq -0x1e8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x6380
jmp 0x2c7a7
movl -0x224(%rbp), %edx
movl -0x228(%rbp), %esi
movq -0x200(%rbp), %rdi
movl -0x1c(%rbp), %r9d
leaq -0x1c8(%rbp), %rcx
leaq -0x1e8(%rbp), %r8
callq 0x2c5c0
jmp 0x2c7d3
leaq -0x1e8(%rbp), %rdi
callq 0x6230
leaq -0x1c8(%rbp), %rdi
callq 0x6230
leaq -0x198(%rbp), %rdi
callq 0x6090
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x2c852
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x2c846
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x6230
leaq -0x1c8(%rbp), %rdi
callq 0x6230
leaq -0x198(%rbp), %rdi
callq 0x6090
movq -0x1a0(%rbp), %rdi
callq 0x6630
nopw (%rax,%rax)
// File: Altius[P]hotspot2/src/resolveOverlapsInSummit-CenteredPeaks.cpp
// Function: Peak_coordLT(Peak const&, Peak const&)
bool Peak_coordLT(const Peak& a, const Peak& b)
{
  if (a.beg == b.beg)
    {
      if (a.end == b.end)
	{
	  if (a.id == b.id)
	    return a.score < b.score;
	  else
	    return a.id < b.id;
	}
      else
	return a.end < b.end;
    }
  return a.beg < b.beg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x2578
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x255e
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
callq 0x3000
testb $0x1, %al
jne 0x2523
jmp 0x2542
movq -0x10(%rbp), %rax
movss 0x50(%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0x50(%rax), %xmm0
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2590
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
callq 0x3090
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2590
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x28(%rcx), %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2590
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Altius[P]hotspot2/src/resolveOverlapsInSummit-CenteredPeaks.cpp
// Function: resolveOverlaps(std::__cxx11::list<Peak, std::allocator<Peak>>&)
void resolveOverlaps(list<Peak>& peaks)
{
  peaks.sort(Peak_scoreGT);

  for (list<Peak>::iterator it1 = peaks.begin(); it1 != peaks.end(); it1++)
    {
      list<Peak>::iterator it2(it1);
      it2++;
      while (it2 != peaks.end())
	{
	  if (it2->beg < it1->end && it2->end > it1->beg)
	    {
	      list<Peak>::iterator it3(it2);
	      it2++;
	      peaks.erase(it3);
	    }
	  else
	    it2++;
	}
    }
  // restore to genomic, sort-bed order
  peaks.sort(Peak_coordLT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x4a(%rip), %rsi       # 0x25a0
callq 0x30d0
movq -0x8(%rbp), %rdi
callq 0x34e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3540
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3510
testb $0x1, %al
jne 0x261f
jmp 0x2710
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x3570
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3540
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3510
testb $0x1, %al
jne 0x2659
jmp 0x26fa
leaq -0x20(%rbp), %rdi
callq 0x35a0
movq 0x20(%rax), %rax
movq %rax, -0x68(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x35a0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq 0x28(%rcx), %rax
jge 0x26e6
leaq -0x20(%rbp), %rdi
callq 0x35a0
movq 0x28(%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x35a0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq 0x20(%rcx), %rax
jle 0x26e6
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x3570
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3610
movq -0x78(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x35c0
movq %rax, -0x50(%rbp)
jmp 0x26f5
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x3570
movq %rax, -0x58(%rbp)
jmp 0x2636
jmp 0x26fc
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3570
movq %rax, -0x60(%rbp)
jmp 0x25fc
movq -0x8(%rbp), %rdi
leaq -0x24b(%rip), %rsi      # 0x24d0
callq 0x30d0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: Altius[P]hotspot2/src/resolveOverlapsInSummit-CenteredPeaks.cpp
// Function: main
int main(int argc, const char* argv[])
{
  ios_base::sync_with_stdio(false); // calling this static method in this way turns off checks, and can speed up I/O

  if (!parseInputWriteOutput()) // see comment accompanying the function re: input and output
    return -1;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %edi, %edi
callq 0x20b0
callq 0x2a40
testb $0x1, %al
jne 0x2fef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2ff6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: WayfireWM[P]wf-utils/wayfire/condition/logic_condition.cpp
// Function: wf::or_condition_t::evaluate(wf::access_interface_t&, bool&)
bool or_condition_t::evaluate(access_interface_t &interface, bool &error)
{
    if ((error) || (left == nullptr) || (right == nullptr))
    {
        error = true;
        return false;
    }

    return left->evaluate(interface, error) | right->evaluate(interface, error);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, (%rax)
jne 0x9e45
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9ed0
testb $0x1, %al
jne 0x9e45
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9ed0
testb $0x1, %al
jne 0x9e45
jmp 0x9e54
movq 0x18(%rsp), %rax
movb $0x1, (%rax)
movb $0x0, 0x37(%rsp)
jmp 0x9eb9
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x9f00
movq %rax, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x10(%rsp), %rdi
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
callq 0x9f00
movq %rax, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, %cl
movl 0xc(%rsp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: WayfireWM[P]wf-utils/wayfire/condition/logic_condition.cpp
// Function: wf::or_condition_t::to_string[abi:cxx11]() const
std::string or_condition_t::to_string() const
{
    std::string out = "(";
    if (left != nullptr)
    {
        out.append(left->to_string());
    }
    else
    {
        out.append("nullptr");
    }
    out.append(" | ");
    if (right != nullptr)
    {
        out.append(right->to_string());
    }
    else
    {
        out.append("nullptr");
    }
    out.append(")");
    return out;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x77(%rsp)
leaq 0x76(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6500
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x15fe2(%rip), %rsi     # 0x1ff41
callq 0x8280
jmp 0x9f66
leaq 0x76(%rsp), %rdi
callq 0x6360
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa110
testb $0x1, %al
jne 0x9f8b
jmp 0xa016
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x9f00
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x40(%rsp), %rdi
callq *%rax
jmp 0x9fac
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x6560
jmp 0x9fbd
leaq 0x40(%rsp), %rdi
callq 0x61d0
jmp 0xa02b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x76(%rsp), %rdi
callq 0x6360
jmp 0xa102
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xa0f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x61d0
jmp 0xa0f8
movq 0x10(%rsp), %rdi
leaq 0x1503a(%rip), %rsi     # 0x1f05c
callq 0x6540
jmp 0xa029
jmp 0xa02b
movq 0x10(%rsp), %rdi
leaq 0x1502d(%rip), %rsi     # 0x1f064
callq 0x6540
jmp 0xa03e
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa110
testb $0x1, %al
jne 0xa056
jmp 0xa0ae
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x9f00
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x20(%rsp), %rdi
callq *%rax
jmp 0xa077
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6560
jmp 0xa088
leaq 0x20(%rsp), %rdi
callq 0x61d0
jmp 0xa0c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x61d0
jmp 0xa0f8
movq 0x10(%rsp), %rdi
leaq 0x14fa2(%rip), %rsi     # 0x1f05c
callq 0x6540
jmp 0xa0c1
jmp 0xa0c3
movq 0x10(%rsp), %rdi
leaq 0x15e47(%rip), %rsi     # 0x1ff16
callq 0x6540
jmp 0xa0d6
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0xa0ec
movq 0x10(%rsp), %rdi
callq 0x61d0
movq (%rsp), %rax
addq $0x88, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x61d0
movq 0x68(%rsp), %rdi
callq 0x64f0
nopl (%rax)
// File: WayfireWM[P]wf-utils/wayfire/condition/logic_condition.cpp
// Function: wf::and_condition_t::evaluate(wf::access_interface_t&, bool&)
bool and_condition_t::evaluate(access_interface_t &interface, bool &error)
{
    if ((error) || (left == nullptr) || (right == nullptr))
    {
        error = true;
        return false;
    }

    return left->evaluate(interface, error) & right->evaluate(interface, error);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, (%rax)
jne 0xa255
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9ed0
testb $0x1, %al
jne 0xa255
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9ed0
testb $0x1, %al
jne 0xa255
jmp 0xa264
movq 0x18(%rsp), %rax
movb $0x1, (%rax)
movb $0x0, 0x37(%rsp)
jmp 0xa2c9
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x9f00
movq %rax, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x10(%rsp), %rdi
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
addq $0x18, %rdi
callq 0x9f00
movq %rax, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
movb %al, %cl
movl 0xc(%rsp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: WayfireWM[P]wf-utils/wayfire/condition/logic_condition.cpp
// Function: wf::and_condition_t::to_string[abi:cxx11]() const
std::string and_condition_t::to_string() const
{
    std::string out = "(";
    if (left != nullptr)
    {
        out.append(left->to_string());
    }
    else
    {
        out.append("nullptr");
    }
    out.append(" & ");
    if (right != nullptr)
    {
        out.append(right->to_string());
    }
    else
    {
        out.append("nullptr");
    }
    out.append(")");
    return out;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x77(%rsp)
leaq 0x76(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6500
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x15c12(%rip), %rsi     # 0x1ff41
callq 0x8280
jmp 0xa336
leaq 0x76(%rsp), %rdi
callq 0x6360
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa110
testb $0x1, %al
jne 0xa35b
jmp 0xa3e6
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x9f00
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x40(%rsp), %rdi
callq *%rax
jmp 0xa37c
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x6560
jmp 0xa38d
leaq 0x40(%rsp), %rdi
callq 0x61d0
jmp 0xa3fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x76(%rsp), %rdi
callq 0x6360
jmp 0xa4d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xa4c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x61d0
jmp 0xa4c8
movq 0x10(%rsp), %rdi
leaq 0x14c6a(%rip), %rsi     # 0x1f05c
callq 0x6540
jmp 0xa3f9
jmp 0xa3fb
movq 0x10(%rsp), %rdi
leaq 0x14c61(%rip), %rsi     # 0x1f068
callq 0x6540
jmp 0xa40e
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa110
testb $0x1, %al
jne 0xa426
jmp 0xa47e
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x9f00
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x20(%rsp), %rdi
callq *%rax
jmp 0xa447
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6560
jmp 0xa458
leaq 0x20(%rsp), %rdi
callq 0x61d0
jmp 0xa493
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x61d0
jmp 0xa4c8
movq 0x10(%rsp), %rdi
leaq 0x14bd2(%rip), %rsi     # 0x1f05c
callq 0x6540
jmp 0xa491
jmp 0xa493
movq 0x10(%rsp), %rdi
leaq 0x15a77(%rip), %rsi     # 0x1ff16
callq 0x6540
jmp 0xa4a6
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0xa4bc
movq 0x10(%rsp), %rdi
callq 0x61d0
movq (%rsp), %rax
addq $0x88, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x61d0
movq 0x68(%rsp), %rdi
callq 0x64f0
nopl (%rax)
// File: WayfireWM[P]wf-utils/wayfire/condition/logic_condition.cpp
// Function: wf::not_condition_t::evaluate(wf::access_interface_t&, bool&)
bool not_condition_t::evaluate(access_interface_t &interface, bool &error)
{
    if ((error) || (child == nullptr))
    {
        error = true;
        return false;
    }

    return !child->evaluate(interface, error);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
jne 0xa5cd
movq (%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9ed0
testb $0x1, %al
jne 0xa5cd
jmp 0xa5dc
movq 0x8(%rsp), %rax
movb $0x1, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0xa604
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x9f00
movq %rax, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: WayfireWM[P]wf-utils/wayfire/condition/logic_condition.cpp
// Function: wf::not_condition_t::to_string[abi:cxx11]() const
std::string not_condition_t::to_string() const
{
    std::string out = "(!";
    if (child != nullptr)
    {
        out.append(child->to_string());
    }
    else
    {
        out.append("nullptr");
    }
    out.append(")");
    return out;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x57(%rsp)
leaq 0x56(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x6500
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x14a13(%rip), %rsi     # 0x1f06c
callq 0x8280
jmp 0xa660
leaq 0x56(%rsp), %rdi
callq 0x6360
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa110
testb $0x1, %al
jne 0xa685
jmp 0xa707
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x9f00
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x20(%rsp), %rdi
callq *%rax
jmp 0xa6a6
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6560
jmp 0xa6b7
leaq 0x20(%rsp), %rdi
callq 0x61d0
jmp 0xa71c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x56(%rsp), %rdi
callq 0x6360
jmp 0xa758
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xa74e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x61d0
jmp 0xa74e
movq 0x10(%rsp), %rdi
leaq 0x14949(%rip), %rsi     # 0x1f05c
callq 0x6540
jmp 0xa71a
jmp 0xa71c
movq 0x10(%rsp), %rdi
leaq 0x157ee(%rip), %rsi     # 0x1ff16
callq 0x6540
jmp 0xa72f
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0xa745
movq 0x10(%rsp), %rdi
callq 0x61d0
movq (%rsp), %rax
addq $0x68, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x61d0
movq 0x48(%rsp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: WayfireWM[P]wf-utils/wayfire/condition/test_condition.cpp
// Function: wf::equals_condition_t::evaluate(wf::access_interface_t&, bool&)
bool equals_condition_t::evaluate(access_interface_t &interface, bool &error)
{
    if (error)
    {
        return false;
    }

    auto value = interface.get(_identifier, error);

    if (error)
    {
        return false;
    }

    return value == _value;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
testb $0x1, (%rax)
je 0xad61
movb $0x0, 0x77(%rsp)
jmp 0xade9
movq 0x10(%rsp), %rdx
movq 0x60(%rsp), %rsi
addq $0x8, %rdx
movq 0x58(%rsp), %rcx
movq (%rsi), %rax
leaq 0x30(%rsp), %rdi
callq *0x10(%rax)
movq 0x58(%rsp), %rax
testb $0x1, (%rax)
je 0xad98
movb $0x0, 0x77(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0xaddf
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
leaq 0x30(%rsp), %rdi
callq 0xae00
movb %al, 0xf(%rsp)
jmp 0xadb1
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x77(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0xaddf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x99d0
jmp 0xadf4
leaq 0x30(%rsp), %rdi
callq 0x99d0
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x64f0
nop
// File: WayfireWM[P]wf-utils/wayfire/condition/test_condition.cpp
// Function: wf::equals_condition_t::to_string[abi:cxx11]() const
std::string equals_condition_t::to_string() const
{
    std::string out = _identifier;
    out.append(" equals ");
    out.append(wf::to_string(_value));
    return out;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movb $0x0, 0x57(%rsp)
addq $0x8, %rsi
callq 0x6130
movq 0x18(%rsp), %rdi
leaq 0x1423f(%rip), %rsi     # 0x1f0be
callq 0x6540
jmp 0xae86
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
leaq 0x20(%rsp), %rdi
callq 0x1bef0
jmp 0xae9b
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6560
jmp 0xaeac
leaq 0x20(%rsp), %rdi
callq 0x61d0
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0xaef8
jmp 0xaeee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xaf02
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x61d0
jmp 0xaf02
movq 0x18(%rsp), %rdi
callq 0x61d0
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x61d0
movq 0x48(%rsp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
// File: WayfireWM[P]wf-utils/wayfire/condition/test_condition.cpp
// Function: wf::contains_condition_t::evaluate(wf::access_interface_t&, bool&)
bool contains_condition_t::evaluate(access_interface_t &interface, bool &error)
{
    if (error)
    {
        return false;
    }

    auto value = interface.get(_identifier, error);

    if (error)
    {
        return false;
    }

    // If the retrieved value or search value is not a string, this can't work.
    if ((!is_string(value)) || (!is_string(_value)))
    {
        error = true;
        return false;
    }

    return get_string(value).find(get_string(_value)) != std::string::npos;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rax
testb $0x1, (%rax)
je 0xaff6
movb $0x0, 0xb7(%rsp)
jmp 0xb140
movq 0x10(%rsp), %rdx
movq 0xa0(%rsp), %rsi
addq $0x8, %rdx
movq 0x98(%rsp), %rcx
movq (%rsi), %rax
leaq 0x70(%rsp), %rdi
callq *0x10(%rax)
movq 0x98(%rsp), %rax
testb $0x1, (%rax)
je 0xb03c
movb $0x0, 0xb7(%rsp)
movl $0x1, 0x6c(%rsp)
jmp 0xb128
leaq 0x70(%rsp), %rdi
callq 0x1bd70
movb %al, 0xf(%rsp)
jmp 0xb04c
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xb056
jmp 0xb074
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
callq 0x1bd70
movb %al, 0xe(%rsp)
jmp 0xb06a
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0xb0a7
jmp 0xb074
movq 0x98(%rsp), %rax
movb $0x1, (%rax)
movb $0x0, 0xb7(%rsp)
movl $0x1, 0x6c(%rsp)
jmp 0xb128
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xb134
leaq 0x38(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x1bea0
jmp 0xb0b8
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
leaq 0x18(%rsp), %rdi
callq 0x1bea0
jmp 0xb0cd
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x6590
cmpq $-0x1, %rax
setne %al
andb $0x1, %al
movb %al, 0xb7(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x61d0
leaq 0x38(%rsp), %rdi
callq 0x61d0
movl $0x1, 0x6c(%rsp)
jmp 0xb128
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x61d0
jmp 0xb134
leaq 0x70(%rsp), %rdi
callq 0x99d0
jmp 0xb140
leaq 0x70(%rsp), %rdi
callq 0x99d0
jmp 0xb151
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x64f0
nopl (%rax,%rax)
// File: WayfireWM[P]wf-utils/wayfire/condition/test_condition.cpp
// Function: wf::contains_condition_t::to_string[abi:cxx11]() const
std::string contains_condition_t::to_string() const
{
    std::string out = _identifier;
    out.append(" contains ");
    out.append(wf::to_string(_value));
    return out;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movb $0x0, 0x57(%rsp)
addq $0x8, %rsi
callq 0x6130
movq 0x18(%rsp), %rdi
leaq 0x13f28(%rip), %rsi     # 0x1f0c7
callq 0x6540
jmp 0xb1a6
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
leaq 0x20(%rsp), %rdi
callq 0x1bef0
jmp 0xb1bb
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6560
jmp 0xb1cc
leaq 0x20(%rsp), %rdi
callq 0x61d0
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0xb218
jmp 0xb20e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xb222
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x61d0
jmp 0xb222
movq 0x18(%rsp), %rdi
callq 0x61d0
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x61d0
movq 0x48(%rsp), %rdi
callq 0x64f0
nopw %cs:(%rax,%rax)
// File: WayfireWM[P]wf-utils/wayfire/lexer/lexer.cpp
// Function: wf::lexer_t::reset()
void lexer_t::reset()
{
    _parse_position = 0;
    _symbol_position = 0;
    _reversed = 0;
    _history.clear();
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movq $0x0, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
addq $0x40, %rdi
callq 0xc250
popq %rax
retq
nopl (%rax)
// File: WayfireWM[P]wf-utils/wayfire/lexer/lexer.cpp
// Function: wf::lexer_t::reverse()
void lexer_t::reverse()
{
    if (_reversed < _history.size())
    {
        ++_reversed;

        auto position = _history.size() - _reversed;
        auto pair = _history.at(position);
        _symbol_position = std::get<size_t>(pair);
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x38(%rdi), %rax
movq %rax, 0x8(%rsp)
addq $0x40, %rdi
callq 0xc500
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xcbe4
movq (%rsp), %rdi
movq 0x38(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x38(%rdi)
addq $0x40, %rdi
callq 0xc500
movq (%rsp), %rdi
subq 0x38(%rdi), %rax
movq %rax, 0x48(%rsp)
addq $0x40, %rdi
movq 0x48(%rsp), %rsi
callq 0xc520
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0xc560
leaq 0x10(%rsp), %rdi
callq 0xcbf0
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x30(%rax)
leaq 0x10(%rsp), %rdi
callq 0xc610
addq $0x58, %rsp
retq
nopl (%rax)
// File: WayfireWM[P]wf-utils/wayfire/parser/condition_parser.cpp
// Function: wf::condition_parser_t::_expression(wf::lexer_t&)
void condition_parser_t::_expression(lexer_t &lexer)
{
    _term(lexer);
    while ((_symbol.type == symbol_t::type_t::OPERATOR) && (get_string(_symbol.value) == "|"))
    {
        auto or_condition = std::make_shared<or_condition_t>();
        or_condition->left = _root;
        _term(lexer);
        or_condition->right = _root;
        _root = or_condition;
    }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x78(%rsp), %rsi
callq 0x14430
movq 0x28(%rsp), %rax
movl 0x10(%rax), %ecx
movb $0x0, 0x57(%rsp)
xorl %eax, %eax
cmpl $0x3, %ecx
movb %al, 0x27(%rsp)
jne 0x14311
movq 0x28(%rsp), %rsi
addq $0x18, %rsi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1bea0
movq 0x18(%rsp), %rdi
movb $0x1, 0x57(%rsp)
leaq 0xaf06(%rip), %rsi      # 0x1f202
callq 0xcc20
movb %al, 0x26(%rsp)
jmp 0x14307
movb 0x26(%rsp), %al
movb %al, 0x27(%rsp)
jmp 0x14311
movb 0x27(%rsp), %al
movb %al, 0x17(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x14322
jmp 0x1432c
leaq 0x58(%rsp), %rdi
callq 0x61d0
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x14339
jmp 0x143ea
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x145a0
movq 0x8(%rsp), %rdi
callq 0x14610
movq 0x28(%rsp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
callq 0x14620
movq 0x28(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x14430
jmp 0x14374
leaq 0x30(%rsp), %rdi
callq 0x14610
movq 0x28(%rsp), %rsi
movq %rax, %rdi
addq $0x18, %rdi
callq 0x14620
movq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x14650
leaq 0x30(%rsp), %rdi
callq 0x14680
jmp 0x142bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x143c4
jmp 0x143ce
leaq 0x58(%rsp), %rdi
callq 0x61d0
jmp 0x143f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x14680
jmp 0x143f2
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x64f0
nopl (%rax)
// File: WayfireWM[P]wf-utils/wayfire/parser/condition_parser.cpp
// Function: wf::condition_parser_t::_term(wf::lexer_t&)
void condition_parser_t::_term(lexer_t &lexer)
{
    _factor(lexer);
    while ((_symbol.type == symbol_t::type_t::OPERATOR) && (get_string(_symbol.value) == "&"))
    {
        auto and_condition = std::make_shared<and_condition_t>();
        and_condition->left = _root;
        _factor(lexer);
        and_condition->right = _root;
        _root = and_condition;
    }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x78(%rsp), %rsi
callq 0x14690
movq 0x28(%rsp), %rax
movl 0x10(%rax), %ecx
movb $0x0, 0x57(%rsp)
xorl %eax, %eax
cmpl $0x3, %ecx
movb %al, 0x27(%rsp)
jne 0x144b1
movq 0x28(%rsp), %rsi
addq $0x18, %rsi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1bea0
movq 0x18(%rsp), %rdi
movb $0x1, 0x57(%rsp)
leaq 0xad64(%rip), %rsi      # 0x1f200
callq 0xcc20
movb %al, 0x26(%rsp)
jmp 0x144a7
movb 0x26(%rsp), %al
movb %al, 0x27(%rsp)
jmp 0x144b1
movb 0x27(%rsp), %al
movb %al, 0x17(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x144c2
jmp 0x144cc
leaq 0x58(%rsp), %rdi
callq 0x61d0
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x144d9
jmp 0x1458a
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x14f70
movq 0x8(%rsp), %rdi
callq 0x14fe0
movq 0x28(%rsp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
callq 0x14620
movq 0x28(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x14690
jmp 0x14514
leaq 0x30(%rsp), %rdi
callq 0x14fe0
movq 0x28(%rsp), %rsi
movq %rax, %rdi
addq $0x18, %rdi
callq 0x14620
movq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x14ff0
leaq 0x30(%rsp), %rdi
callq 0x15020
jmp 0x1445b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x14564
jmp 0x1456e
leaq 0x58(%rsp), %rdi
callq 0x61d0
jmp 0x14592
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x15020
jmp 0x14592
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x64f0
nopl (%rax)
// File: WayfireWM[P]wf-utils/wayfire/rule/lambda_rule.cpp
// Function: wf::lambda_rule_t::apply(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, wf::access_interface_t&)
bool lambda_rule_t::apply(const std::string &signal, access_interface_t &access)
{
    if ((signal.empty()) || (_condition == nullptr) || (_if_lambda == nullptr))
    {
        return true;
    }

    bool error = false;
    if (signal == _signal)
    {
        auto check_result = _condition->evaluate(access, error);
        if (!error)
        {
            if (check_result)
            {
                error = _if_lambda();
            }
            else
            {
                if (_else_lambda != nullptr)
                {
                    error = _else_lambda();
                }
            }

        }
    }

    return error;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x64c0
testb $0x1, %al
jne 0x1b459
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9ed0
testb $0x1, %al
jne 0x1b459
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b510
testb $0x1, %al
jne 0x1b459
jmp 0x1b463
movb $0x1, 0x37(%rsp)
jmp 0x1b504
movq 0x8(%rsp), %rsi
movb $0x0, 0x17(%rsp)
movq 0x20(%rsp), %rdi
callq 0xbed0
testb $0x1, %al
jne 0x1b47d
jmp 0x1b4fa
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x9f00
movq %rax, %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
leaq 0x17(%rsp), %rdx
callq *0x10(%rax)
andb $0x1, %al
movb %al, 0x16(%rsp)
testb $0x1, 0x17(%rsp)
jne 0x1b4f8
testb $0x1, 0x16(%rsp)
je 0x1b4c8
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x1b540
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x1b4f6
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b580
testb $0x1, %al
jne 0x1b4e0
jmp 0x1b4f4
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0x1b540
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x1b4f6
jmp 0x1b4f8
jmp 0x1b4fa
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: WayfireWM[P]wf-utils/main.cpp
// Function: test_access_interface_t::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool&)
virtual wf::variant_t get(const std::string &identifier, bool &error) override
    {
        error = false;
        if (_test != nullptr)
        {
            if (identifier == "property_a")
            {
                return _test->property_a;
            }
            else if (identifier == "property_b")
            {
                return _test->get_property_b();
            }
            else if (identifier == "title")
            {
                return _test->title;
            }
        }

        error = true;
        return wf::variant_t("");
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x28(%rsp), %rax
movb $0x0, (%rax)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d510
testb $0x1, %al
jne 0x1d38d
jmp 0x1d446
movq 0x30(%rsp), %rdi
leaq 0x2b4b(%rip), %rsi      # 0x1fee4
callq 0xcc20
testb $0x1, %al
jne 0x1d3a4
jmp 0x1d3c4
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x1d220
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x1d530
jmp 0x1d45f
movq 0x30(%rsp), %rdi
leaq 0x2b1f(%rip), %rsi      # 0x1feef
callq 0xcc20
testb $0x1, %al
jne 0x1d3db
jmp 0x1d408
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x1d220
movq %rax, %rdi
callq 0x1d560
movq 0x8(%rsp), %rdi
vmovsd %xmm0, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x10dd0
jmp 0x1d45f
movq 0x30(%rsp), %rdi
leaq 0x2ae6(%rip), %rsi      # 0x1fefa
callq 0xcc20
testb $0x1, %al
jne 0x1d41f
jmp 0x1d440
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x1d220
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x1d5b0
jmp 0x1d45f
jmp 0x1d442
jmp 0x1d444
jmp 0x1d446
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rax
movb $0x1, (%rax)
leaq 0x1c11(%rip), %rsi      # 0x1f06b
callq 0x1d5e0
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: ksabry[P]bfbrute/src/Main.cpp
// Function: FindString()
void FindString()
{
	constexpr uint_fast32_t DATA_SIZE = 400;
	constexpr uint_fast32_t CACHE_DATA_SIZE = 32;
	constexpr uint_fast32_t CACHE_SIZE = 12;
	
	std::vector<const char*> inputs = {
		""
	};
	std::vector<const char*> outputs = {
		"Hello, World!"
	};

	ProgramSearch<
		ProgramIterator<DATA_SIZE, CACHE_DATA_SIZE, CACHE_SIZE>,
		DataCache<CACHE_DATA_SIZE, CACHE_SIZE>>
	search(inputs, outputs);

	search.FindString();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x85b80, %rsp          # imm = 0x85B80
movq $0x190, -0x8(%rbp)      # imm = 0x190
movq $0x20, -0x10(%rbp)
movq $0xc, -0x18(%rbp)
leaq 0x10023(%rip), %rax     # 0x1381d
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x1, -0x38(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x85b78(%rbp)
callq 0x3f60
movq -0x85b78(%rbp), %rcx
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3f80
jmp 0x3838
leaq -0x49(%rbp), %rdi
callq 0x4000
leaq 0xf8e0(%rip), %rax      # 0x13128
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rax
movq %rax, -0x88(%rbp)
movq $0x1, -0x80(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0x85b80(%rbp)
callq 0x3f60
movq -0x85b80(%rbp), %rcx
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x3f80
jmp 0x3895
leaq -0x91(%rbp), %rdi
callq 0x4000
leaq -0x85b58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4020
jmp 0x38b3
leaq -0x85b70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x4020
jmp 0x38c5
leaq -0x85b40(%rbp), %rdi
leaq -0x85b58(%rbp), %rsi
leaq -0x85b70(%rbp), %rdx
callq 0x4110
jmp 0x38e1
leaq -0x85b70(%rbp), %rdi
callq 0x42b0
leaq -0x85b58(%rbp), %rdi
callq 0x42b0
leaq -0x85b40(%rbp), %rdi
callq 0x4310
jmp 0x3907
leaq -0x85b40(%rbp), %rdi
callq 0x4370
leaq -0x78(%rbp), %rdi
callq 0x42b0
leaq -0x30(%rbp), %rdi
callq 0x42b0
addq $0x85b80, %rsp          # imm = 0x85B80
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x4000
jmp 0x39ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x91(%rbp), %rdi
callq 0x4000
jmp 0x39c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x39bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3996
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x85b70(%rbp), %rdi
callq 0x42b0
leaq -0x85b58(%rbp), %rdi
callq 0x42b0
jmp 0x39bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x85b40(%rbp), %rdi
callq 0x4370
leaq -0x78(%rbp), %rdi
callq 0x42b0
leaq -0x30(%rbp), %rdi
callq 0x42b0
movq -0x58(%rbp), %rdi
callq 0x34d0
nopw (%rax,%rax)
// File: ksabry[P]bfbrute/src/RawSourceExecutor.h
// Function: RawSourceExecutor<400ul, 32ul>::Execute()
bool Execute()
	{
		uint_fast32_t program_idx = 0;
		data_idx = data_size / 2;
		memset(data, 0, data_size);

		while (program_idx < source.length())
		{
			switch (source[program_idx])
			{
				case '+':
					data[data_idx]++;
					program_idx++;
					break;
				case '-':
					data[data_idx]--;
					program_idx++;
					break;
				case '>':
					data_idx++;
					program_idx++;
					break;
				case '<':
					data_idx--;
					program_idx++;
					break;
				case '[':
				case ']':
					program_idx = data[data_idx] == 0 ? jumps[program_idx].zero : jumps[program_idx].nonzero;
					break;
			}
			if (data_idx < 0 || data_idx >= data_size)
			{
				return false;
			}
		}
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq $0xc8, 0x4b0(%rdi)
addq $0x320, %rdi            # imm = 0x320
xorl %esi, %esi
movl $0x190, %edx            # imm = 0x190
callq 0x3110
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x3410
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x3d54
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3570
movsbl (%rax), %eax
addl $-0x2b, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x32, %eax
ja 0x3d2a
movq -0x30(%rbp), %rax
leaq 0xf3dc(%rip), %rcx      # 0x13004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq 0x4b0(%rax), %rcx
movb 0x320(%rax,%rcx), %dl
addb $0x1, %dl
movb %dl, 0x320(%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3d2a
movq -0x20(%rbp), %rax
movq 0x4b0(%rax), %rcx
movb 0x320(%rax,%rcx), %dl
addb $-0x1, %dl
movb %dl, 0x320(%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3d2a
movq -0x20(%rbp), %rax
movq 0x4b0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x4b0(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3d2a
movq -0x20(%rbp), %rax
movq 0x4b0(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x4b0(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3d2a
movq -0x20(%rbp), %rax
movq 0x4b0(%rax), %rcx
movzbl 0x320(%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x3d07
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x3d22
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x4b0(%rax)
jl 0x3d49
movq -0x20(%rbp), %rax
cmpq $0x190, 0x4b0(%rax) # imm = 0x190
jb 0x3d4f
movb $0x0, -0x1(%rbp)
jmp 0x3d58
jmp 0x3bda
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ksabry[P]bfbrute/src/RawSourceExecutor.h
// Function: RawSourceExecutor<400ul, 32ul>::PrintData()
void PrintData()
	{
		uint_fast32_t data_bound_low = 0;
		uint_fast32_t data_bound_high = data_size - 1;
		while (data_bound_low < data_size) {
			if (data[data_bound_low] != 0)
			{
				break;
			}
			data_bound_low++;
		}
		while (data_bound_high > data_bound_low)
		{
			if (data[data_bound_high] != 0)
			{
				break;
			}
			data_bound_high--;
		}

		for (uint_fast32_t i = data_bound_low; i <= data_bound_high; i++)
		{
			std::cout << std::setw(4) << (int)data[i];
		}
		std::cout << std::endl << std::string((data_idx - data_bound_low) * 4, ' ') << "  ^" << std::endl;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x18f, -0x18(%rbp)     # imm = 0x18F
cmpq $0x190, -0x10(%rbp)     # imm = 0x190
jae 0x3dc6
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x320(%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3db8
jmp 0x3dc6
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3d97
jmp 0x3dc8
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x3df7
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl 0x320(%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x3de9
jmp 0x3df7
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3dc8
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x3e4b
movl $0x4, %edi
callq 0x4870
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
movq 0x181b0(%rip), %rdi     # 0x1bfd0
callq 0x3330
movq %rax, %rdi
movq -0x68(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl 0x320(%rax,%rcx), %esi
callq 0x34c0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3dff
movq 0x1817e(%rip), %rdi     # 0x1bfd0
movq 0x1815f(%rip), %rsi     # 0x1bfb8
callq 0x32d0
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq 0x4b0(%rax), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
shlq $0x2, %rax
movq %rax, -0x78(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x34e0
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rcx
leaq -0x48(%rbp), %rdi
movl $0x20, %edx
callq 0x4890
jmp 0x3ea4
movq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3250
movq %rax, -0x88(%rbp)
jmp 0x3eba
movq -0x88(%rbp), %rdi
leaq 0xf298(%rip), %rsi      # 0x13160
callq 0x32a0
movq %rax, -0x90(%rbp)
jmp 0x3ed6
movq -0x90(%rbp), %rdi
movq 0x180d4(%rip), %rsi     # 0x1bfb8
callq 0x32d0
jmp 0x3eeb
leaq -0x48(%rbp), %rdi
callq 0x3160
leaq -0x49(%rbp), %rdi
callq 0x32f0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3f29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3160
leaq -0x49(%rbp), %rdi
callq 0x32f0
movq -0x58(%rbp), %rdi
callq 0x34d0
nopl (%rax,%rax)