LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::tryBryston()
void Signal::tryBryston()   //  {38.0k,315} <1,-6|6,-1>(D:10, F:8, -18)  //DAR 2012 
{
	if ( nFrameL != 18 || !framed(nMaxDur*16) )
		return;
    if ( sortBurst.min1 * 1.15 < sortBurst.max1 )
        return;
	 if ( sortOff.min1 * 8 < sortBurst.max3  || sortOff.min1 * 6 > sortBurst.max3)
        return;
    nMaxShort = sortBurst.min1 * .4;
    cleanup();
	for (int ndx=0; ndx<nFrameL; ++ndx)
	{
		if (pFrame[2*ndx] > nMaxShort)
		{
			if (pFrame[2*ndx+1] > nMaxShort && ndx<nFrameL-1)
				return;
			cBits[ndx>>3] |= 1 << (ndx&7);
		}
	}
	strcpy(pProtocol,"Bryston");
	*pDevice = getLsb(0,10);
	*pOBC = getLsb(10,8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x12, 0x48(%rax)
jne 0x141c8
movq -0x18(%rbp), %rdi
movss 0x5f96(%rip), %xmm0     # 0x1a14c
mulss 0x9c(%rdi), %xmm0
callq 0x18840
cmpl $0x0, %eax
jne 0x141cd
jmp 0x1436b
movq -0x18(%rbp), %rax
movss 0x1d0(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x64e3(%rip), %xmm0     # 0x1a6c8
mulsd %xmm0, %xmm1
movss 0x1dc(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x14200
jmp 0x1436b
movq -0x18(%rbp), %rax
movss 0x5eac(%rip), %xmm1     # 0x1a0b8
mulss 0x18c(%rax), %xmm1
movss 0x1e4(%rax), %xmm0
ucomiss %xmm1, %xmm0
ja 0x1423e
movq -0x18(%rbp), %rax
movss 0x5def(%rip), %xmm0     # 0x1a01c
mulss 0x18c(%rax), %xmm0
ucomiss 0x1e4(%rax), %xmm0
jbe 0x14243
jmp 0x1436b
movq -0x18(%rbp), %rdi
movss 0x1d0(%rdi), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x60fd(%rip), %xmm1     # 0x1a358
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xe8(%rdi)
callq 0x16180
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x48(%rcx), %eax
jge 0x14317
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movl -0xc(%rbp), %edx
shll %edx
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm0
ucomiss 0xe8(%rax), %xmm0
jbe 0x14307
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movl -0xc(%rbp), %edx
shll %edx
addl $0x1, %edx
movslq %edx, %rdx
movss (%rcx,%rdx,4), %xmm0
ucomiss 0xe8(%rax), %xmm0
jbe 0x142dc
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x48(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x142dc
jmp 0x1436b
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
andl $0x7, %ecx
movl $0x1, %esi
shll %cl, %esi
movl -0xc(%rbp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl 0xa0(%rax,%rcx), %edx
orl %esi, %edx
movb %dl, 0xa0(%rax,%rcx)
jmp 0x14309
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x14277
movq -0x18(%rbp), %rax
movq 0x148(%rax), %rdi
leaq 0x6c95(%rip), %rsi      # 0x1afbe
callq 0x2120
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x16030
movq -0x18(%rbp), %rdi
movl %eax, %ecx
movq 0x160(%rdi), %rax
movl %ecx, (%rax)
movl $0xa, %esi
movl $0x8, %edx
callq 0x16030
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq 0x170(%rax), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::tryAdNotam()
void Signal::tryAdNotam()
//
// Ad Notam        {35.7Khz,895,msb}<1,-1|-1,1>(0:1,1:1,D:6,F:6,^114m)+   DAR  August 2012

{
	if ( nFrameL < 6 )
		return;
	const float HB = 889; 
	if ( nTotDur < 10.*HB )
		return;
	if ( sortOn.min1 < HB * .3 )
		return;
	if ( sortOn.max1 > HB * 2.4 )
		return;
	if (   !framed(20*HB)  //framed(nGap) is: return nGap <= frame, which pFramedEnd
		|| nMaxDur > HB*6.5    
        || sortBurst.max2 > HB*4.5  // nominal 2,-2
		|| *pFrame < HB*.5
		|| sortOff.max1 > 3 * HB )
	{
		return;
	}
	cleanup();
    if (!processManchesterAtoms(0, 14, 0, 2*HB, pFrame)) 
		return;
	if (nBit != 14)
		return;
	if (getMsb(0,2) != 1 )
		return;
	*pDevice = getMsb(2,6);
	*pOBC = getMsb(8,6);
	strcpy(pProtocol, "Ad Notam");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x6, 0x48(%rax)
jge 0x146ef
jmp 0x1489a
movq -0x18(%rbp), %rax
movss 0x59ed(%rip), %xmm0     # 0x1a0e8
movss %xmm0, -0xc(%rbp)
movss 0x98(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x5f1c(%rip), %xmm0     # 0x1a630
ucomisd %xmm1, %xmm0
jbe 0x1471f
jmp 0x1489a
movq -0x18(%rbp), %rax
movss 0x180(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x5f01(%rip), %xmm0     # 0x1a638
ucomisd %xmm1, %xmm0
jbe 0x14742
jmp 0x1489a
movq -0x18(%rbp), %rax
movss 0x184(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5ee6(%rip), %xmm1     # 0x1a640
ucomisd %xmm1, %xmm0
jbe 0x14765
jmp 0x1489a
movq -0x18(%rbp), %rdi
movss 0x597b(%rip), %xmm0     # 0x1a0ec
callq 0x18840
cmpl $0x0, %eax
je 0x147ee
movq -0x18(%rbp), %rax
movss 0x9c(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5eb5(%rip), %xmm1     # 0x1a648
ucomisd %xmm1, %xmm0
ja 0x147ee
movq -0x18(%rbp), %rax
movss 0x1e0(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x5e9f(%rip), %xmm1     # 0x1a650
ucomisd %xmm1, %xmm0
ja 0x147ee
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x5e89(%rip), %xmm0     # 0x1a658
ucomisd %xmm1, %xmm0
ja 0x147ee
movq -0x18(%rbp), %rax
movss 0x190(%rax), %xmm0
movss 0x59c7(%rip), %xmm1     # 0x1a1b0
ucomiss %xmm1, %xmm0
jbe 0x147f3
jmp 0x1489a
movq -0x18(%rbp), %rdi
callq 0x16180
movq -0x18(%rbp), %rdi
movq 0x38(%rdi), %rcx
xorl %esi, %esi
movl $0xe, %edx
xorps %xmm0, %xmm0
movss 0x58f2(%rip), %xmm1     # 0x1a108
callq 0x17270
testb $0x1, %al
jne 0x14821
jmp 0x1489a
movq -0x18(%rbp), %rax
cmpl $0xe, 0xc0(%rax)
je 0x14830
jmp 0x1489a
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x15f50
cmpl $0x1, %eax
je 0x14847
jmp 0x1489a
movq -0x18(%rbp), %rdi
movl $0x2, %esi
movl $0x6, %edx
callq 0x15f50
movq -0x18(%rbp), %rdi
movl %eax, %ecx
movq 0x160(%rdi), %rax
movl %ecx, (%rax)
movl $0x8, %esi
movl $0x6, %edx
callq 0x15f50
movl %eax, %edx
movq -0x18(%rbp), %rax
movq 0x170(%rax), %rcx
movl %edx, (%rcx)
movq 0x148(%rax), %rdi
leaq 0x6576(%rip), %rsi      # 0x1ae0b
callq 0x2120
addq $0x20, %rsp
popq %rbp
retq
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::getFreq(int, int)
unsigned int Signal::getFreq(int start, int end)
{
	int s=0;
	double t=0;
	double freq;

	if (pCounts == NULL) return 0;

	for (int n=start; n<end; n++)
	{	
		{
			s += pCounts[2*n];
			t += pDuration[2*n];
		}
	}
	freq = ((s!=end-start)&&(t > 0)) ? s*1000000./t : 0;

	return (unsigned int)freq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x1c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
cmpq $0x0, 0x90(%rax)
jne 0x148db
movl $0x0, -0x4(%rbp)
jmp 0x14985
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x14930
movq -0x40(%rbp), %rax
movq 0x90(%rax), %rcx
movl -0x34(%rbp), %edx
shll %edx
movslq %edx, %rdx
movswl (%rcx,%rdx,2), %ecx
addl -0x1c(%rbp), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x8(%rax), %rax
movl -0x34(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x148e1
movl -0x1c(%rbp), %eax
movl -0x18(%rbp), %ecx
subl -0x14(%rbp), %ecx
cmpl %ecx, %eax
je 0x14968
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x14968
cvtsi2sdl -0x1c(%rbp), %xmm0
movsd 0x5de8(%rip), %xmm1     # 0x1a740
mulsd %xmm1, %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x14972
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x14972
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
cvttsd2si -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::msb(int, int)
int Signal::msb(int val, int bits=8)	
{
	unsigned int t = ((val>>16)&0xFFFF) + ((val&0xFFFF)<<16);
	t = ((t>>8)&0xFF00FF) + ((t&0xFF00FF)<<8);
	t = ((t>>4)&0xF0F0F0F) + ((t&0xF0F0F0F)<<4);
	t = ((t>>2)&0x33333333) + ((t&0x33333333)<<2);
	t = ((t>>1)&0x55555555) + ((t&0x55555555)<<1);
	return t >> (32-bits);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
sarl $0x10, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl -0xc(%rbp), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
shll $0x10, %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
andl $0xff00ff, %eax         # imm = 0xFF00FF
movl -0x14(%rbp), %ecx
andl $0xff00ff, %ecx         # imm = 0xFF00FF
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl $0x4, %eax
andl $0xf0f0f0f, %eax        # imm = 0xF0F0F0F
movl -0x14(%rbp), %ecx
andl $0xf0f0f0f, %ecx        # imm = 0xF0F0F0F
shll $0x4, %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl $0x2, %eax
andl $0x33333333, %eax       # imm = 0x33333333
movl -0x14(%rbp), %ecx
andl $0x33333333, %ecx       # imm = 0x33333333
shll $0x2, %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl %eax
andl $0x55555555, %eax       # imm = 0x55555555
movl -0x14(%rbp), %ecx
andl $0x55555555, %ecx       # imm = 0x55555555
shll %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x20, %ecx
subl -0x10(%rbp), %ecx
shrl %cl, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::getMsb(int, int)
unsigned int Signal::getMsb(int first, int bits)
{
	int byte = first >> 3;
	int bt = 8-(first & 7);
	unsigned int rslt = cBits[byte] & ((1<<bt)-1);
	if ( bt >= bits )
	{
		return rslt >> (bt - bits);
	}
	for (bits-=bt; bits>=8; bits-=8)
		rslt = (rslt<<8) + cBits[++byte];
	return (rslt<<bits) + ((unsigned int)(cBits[1+byte]) >> (8-bits));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %ecx
sarl $0x3, %ecx
movl %ecx, -0x1c(%rbp)
movl -0x14(%rbp), %edx
andl $0x7, %edx
movl $0x8, %ecx
subl %edx, %ecx
movl %ecx, -0x20(%rbp)
movslq -0x1c(%rbp), %rcx
movzbl 0xa0(%rax,%rcx), %eax
movl -0x20(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x15fb7
movl -0x24(%rbp), %eax
movl -0x20(%rbp), %ecx
subl -0x18(%rbp), %ecx
shrl %cl, %eax
movl %eax, -0x4(%rbp)
jmp 0x16024
movl -0x20(%rbp), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jl 0x15ff6
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
shll $0x8, %eax
movl -0x1c(%rbp), %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %edx, %rdx
movzbl 0xa0(%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x18(%rbp)
jmp 0x15fc2
movl -0x24(%rbp), %eax
movl -0x18(%rbp), %ecx
shll %cl, %eax
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl 0xa0(%rcx,%rdx), %edx
movl $0x8, %ecx
subl -0x18(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::getLsb(int, int)
unsigned int Signal::getLsb(int first, int bits)
{
	int byte = first >> 3;
	int bt = first & 7;
	unsigned int rslt = cBits[byte] >> bt;
	bt = 8-bt;
	if ( bt >= bits )
	{
		return rslt & ((1<<bits)-1);
	}
	while ( bt+8 < bits )
	{
		rslt += cBits[++byte] << bt;
		bt += 8;
	}
	return rslt + ( ( cBits[1+byte] & ((1<<(bits-bt))-1) ) << bt );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %ecx
sarl $0x3, %ecx
movl %ecx, -0x1c(%rbp)
movl -0x14(%rbp), %ecx
andl $0x7, %ecx
movl %ecx, -0x20(%rbp)
movslq -0x1c(%rbp), %rcx
movzbl 0xa0(%rax,%rcx), %eax
movl -0x20(%rbp), %ecx
sarl %cl, %eax
movl %eax, -0x24(%rbp)
movl $0x8, %eax
subl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x16098
movl -0x24(%rbp), %eax
movl -0x18(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1610b
jmp 0x1609a
movl -0x20(%rbp), %eax
addl $0x8, %eax
cmpl -0x18(%rbp), %eax
jge 0x160d3
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
movzbl 0xa0(%rax,%rcx), %eax
movl -0x20(%rbp), %ecx
shll %cl, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x20(%rbp)
jmp 0x1609a
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
movl -0x1c(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl 0xa0(%rcx,%rdx), %edx
movl -0x18(%rbp), %ecx
subl -0x20(%rbp), %ecx
movl $0x1, %esi
shll %cl, %esi
movl %esi, %ecx
subl $0x1, %ecx
andl %ecx, %edx
movl -0x20(%rbp), %ecx
shll %cl, %edx
movl %edx, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::cleanup()
void Signal::cleanup()
{
	memset(cBits, 0, sizeof(cBits));
	pBit = pFrame;
	nBit = 0;
	nState = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0xa0, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x20c0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq %rcx, 0xc8(%rax)
movl $0x0, 0xc0(%rax)
movl $0x0, 0xc4(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::decodeX(int)
void Signal::decodeX( int nCount )
{
	_ASSERT(nBit+nCount <= sizeof(cBits)*8);
	while (--nCount >= 0)
	{
		float nDelta = nMaxShort - *pBit;
		if ( nDelta < 0 )
		{
			cBits[nBit>>3] |= 1 << (nBit & 7);
		}
		pBit += 2;
		nBit++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0xc0(%rax), %eax
addl -0xc(%rbp), %eax
cltq
cmpq $0x80, %rax
ja 0x161fc
jmp 0x1621b
leaq 0x47c4(%rip), %rdi      # 0x1a9c7
leaq 0x47dc(%rip), %rsi      # 0x1a9e6
movl $0x2ec, %edx            # imm = 0x2EC
leaq 0x47dd(%rip), %rcx      # 0x1a9f3
callq 0x20e0
jmp 0x1621d
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jl 0x162af
movq -0x18(%rbp), %rax
movss 0xe8(%rax), %xmm0
movq 0xc8(%rax), %rax
subss (%rax), %xmm0
movss %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x10(%rbp), %xmm0
jbe 0x16285
movq -0x18(%rbp), %rax
movl 0xc0(%rax), %ecx
andl $0x7, %ecx
movl $0x1, %esi
shll %cl, %esi
movl 0xc0(%rax), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl 0xa0(%rax,%rcx), %edx
orl %esi, %edx
movb %dl, 0xa0(%rax,%rcx)
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0xc8(%rax)
movl 0xc0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc0(%rax)
jmp 0x1621d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::decodeX2(int)
void Signal::decodeX2( int nCount )
{
	_ASSERT(nBit+nCount <= sizeof(cBits)*8);
	while (--nCount >= 0)
	{
		if ( pBit[0]+pBit[1] > nMaxShort )
		{
			cBits[nBit>>3] |= 1 << (nBit & 7);
		}
		pBit += 2;
		nBit++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0xc0(%rax), %eax
addl -0xc(%rbp), %eax
cltq
cmpq $0x80, %rax
ja 0x162ec
jmp 0x1630b
leaq 0x46d4(%rip), %rdi      # 0x1a9c7
leaq 0x46ec(%rip), %rsi      # 0x1a9e6
movl $0x2fb, %edx            # imm = 0x2FB
leaq 0x4707(%rip), %rcx      # 0x1aa0d
callq 0x20e0
jmp 0x1630d
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jl 0x1639a
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rcx
movss (%rcx), %xmm0
movq 0xc8(%rax), %rcx
addss 0x4(%rcx), %xmm0
ucomiss 0xe8(%rax), %xmm0
jbe 0x16370
movq -0x18(%rbp), %rax
movl 0xc0(%rax), %ecx
andl $0x7, %ecx
movl $0x1, %esi
shll %cl, %esi
movl 0xc0(%rax), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl 0xa0(%rax,%rcx), %edx
orl %esi, %edx
movb %dl, 0xa0(%rax,%rcx)
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0xc8(%rax)
movl 0xc0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc0(%rax)
jmp 0x1630d
addq $0x20, %rsp
popq %rbp
retq
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::checkDecodeX(int, int, float, float, float)
int Signal::checkDecodeX( int start, int count, float minShort, float maxLong, float maxFront )
{
	_ASSERT(nBit+count <= sizeof(cBits)*8);
	float *pB = pFrame+start;
	if (   pB >= pMainLimit
		|| pB+2*count > pFullLimit )
	{
		return 0;
	}
	while (--count >= 0)
	{
		double burst = pB[0]+pB[1];
		if (   burst < minShort
			|| burst > maxLong
			|| pB[0] > maxFront )
		{
			return 0;
		}
		if ( burst > nMaxShort )
		{
			cBits[nBit>>3] |= 1 << (nBit & 7);
		}
		pB += 2;
		nBit++;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movss %xmm1, -0x20(%rbp)
movss %xmm2, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0xc0(%rax), %eax
addl -0x18(%rbp), %eax
cltq
cmpq $0x80, %rax
ja 0x163de
jmp 0x163fd
leaq 0x4643(%rip), %rdi      # 0x1aa28
leaq 0x45fa(%rip), %rsi      # 0x1a9e6
movl $0x309, %edx            # imm = 0x309
leaq 0x464e(%rip), %rcx      # 0x1aa46
callq 0x20e0
movq -0x40(%rbp), %rcx
movq 0x38(%rcx), %rax
movslq -0x14(%rbp), %rdx
shlq $0x2, %rdx
addq %rdx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x1643b
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movl -0x18(%rbp), %edx
shll %edx
movslq %edx, %rdx
shlq $0x2, %rdx
addq %rdx, %rax
cmpq 0x18(%rcx), %rax
jbe 0x16447
movl $0x0, -0x4(%rbp)
jmp 0x1652b
jmp 0x16449
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jl 0x16524
movq -0x30(%rbp), %rax
movss (%rax), %xmm0
movq -0x30(%rbp), %rax
addss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x164ab
movsd -0x38(%rbp), %xmm0
movss -0x20(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
ja 0x164ab
movq -0x30(%rbp), %rax
movss (%rax), %xmm0
ucomiss -0x24(%rbp), %xmm0
jbe 0x164b4
movl $0x0, -0x4(%rbp)
jmp 0x1652b
movq -0x40(%rbp), %rax
movsd -0x38(%rbp), %xmm0
movss 0xe8(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x16500
movq -0x40(%rbp), %rax
movl 0xc0(%rax), %ecx
andl $0x7, %ecx
movl $0x1, %esi
shll %cl, %esi
movl 0xc0(%rax), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl 0xa0(%rax,%rcx), %edx
orl %esi, %edx
movb %dl, 0xa0(%rax,%rcx)
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
addq $0x8, %rcx
movq %rcx, -0x30(%rbp)
movl 0xc0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc0(%rax)
jmp 0x16449
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::moreBlaupunkt(int)
int Signal::moreBlaupunkt(int bits)
{
	if (   pBit+3 >= pMainLimit
		|| pBit[2] <= sortBurst.max2
		|| pBit[2] > sortBurst.max1
		|| pBit[1] > nMaxShort
		|| pBit[3] > nMaxShort )
	{
		return -1;
	}
	float* save_pBit = pBit;
	cleanup();
	pBit = save_pBit + 4;      // Middle of first bit
	nState = 1;
	for (;;)
	{
		if ( pBit >= pFullLimit )
			break;
		if ( ! phaseBit() )
			break;
		if ( nBit == bits )
		{
			pBit = ((pBit-pDuration)|1)+pDuration;
			if (pBit < pFullLimit && pBit[0] < sortBurst.max1)
				break;
			return getLsb(0,bits);
		}
	}
	pBit = save_pBit;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0xc8(%rcx), %rax
addq $0xc, %rax
cmpq 0x10(%rcx), %rax
jae 0x17780
movq -0x28(%rbp), %rax
movq 0xc8(%rax), %rcx
movss 0x8(%rcx), %xmm1
movss 0x1e0(%rax), %xmm0
ucomiss %xmm1, %xmm0
jae 0x17780
movq -0x28(%rbp), %rax
movq 0xc8(%rax), %rcx
movss 0x8(%rcx), %xmm0
ucomiss 0x1dc(%rax), %xmm0
ja 0x17780
movq -0x28(%rbp), %rax
movq 0xc8(%rax), %rcx
movss 0x4(%rcx), %xmm0
ucomiss 0xe8(%rax), %xmm0
ja 0x17780
movq -0x28(%rbp), %rax
movq 0xc8(%rax), %rcx
movss 0xc(%rcx), %xmm0
ucomiss 0xe8(%rax), %xmm0
jbe 0x1778c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x17874
movq -0x28(%rbp), %rdi
movq 0xc8(%rdi), %rax
movq %rax, -0x20(%rbp)
callq 0x16180
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x10, %rcx
movq %rcx, 0xc8(%rax)
movl $0x1, 0xc4(%rax)
movq -0x28(%rbp), %rcx
movq 0xc8(%rcx), %rax
cmpq 0x18(%rcx), %rax
jb 0x177d3
jmp 0x1785e
movq -0x28(%rbp), %rdi
callq 0x17050
cmpl $0x0, %eax
jne 0x177e3
jmp 0x1785e
movq -0x28(%rbp), %rax
movl 0xc0(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x17859
movq -0x28(%rbp), %rcx
movq 0xc8(%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rdx, %rax
sarq $0x2, %rax
orq $0x1, %rax
shlq $0x2, %rax
addq 0x8(%rcx), %rax
movq %rax, 0xc8(%rcx)
movq 0xc8(%rcx), %rax
cmpq 0x18(%rcx), %rax
jae 0x17846
movq -0x28(%rbp), %rax
movq 0xc8(%rax), %rcx
movss (%rcx), %xmm1
movss 0x1dc(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x17846
jmp 0x1785e
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %edx
xorl %esi, %esi
callq 0x16030
movl %eax, -0x4(%rbp)
jmp 0x17874
jmp 0x177bd
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0xc8(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: probonopd[P]decodeir/DecodeIR.cpp
// Function: ProtocolSupportLevel
int _stdcall ProtocolSupportLevel(char* TsProtocol)				
{

	for (int ndx=sizeof(Protocols)/sizeof(*Protocols); --ndx>=0; )
		if ( strnicmp( Protocols[ndx], TsProtocol, strlen(Protocols[ndx]) ) == 0 )
			return 1;
	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x33, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jl 0x17940
movslq -0x14(%rbp), %rcx
leaq 0x7844(%rip), %rax      # 0x1f140
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x7829(%rip), %rax      # 0x1f140
movq (%rax,%rcx,8), %rdi
callq 0x20a0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x21b0
cmpl $0x0, %eax
jne 0x1793e
movl $0x1, -0x4(%rbp)
jmp 0x17947
jmp 0x178e3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: probonopd[P]decodeir/./DecodeIR.h
// Function: setOn::insert(float*)
void insert( burst b )
    {
        double x = b[0];
        if ( x < min1 ) min1 = x;
        if ( x > max2 )
        {
            if ( x > max1 )
            {
                max2 = max1;
                max1 = x;
                return;
            }
            max2 = x;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movss (%rcx), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm1
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x18209
movq -0x20(%rbp), %rax
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movss 0x8(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x18269
movq -0x20(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movss 0x4(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x18257
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
jmp 0x18269
movq -0x20(%rbp), %rax
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: probonopd[P]decodeir/./DecodeIR.h
// Function: setBurst::insert1(float*)
void insert1( burst b )
    {
        double x = b[0]+b[1];
        super::insert( x );
        if ( x < min3 )
        {
            if ( x >= min2 )
            {
                min3 = x;
            }
            else
            {
                min3 = min2;
                if ( x >= min1 )
                {
                    min2 = x;
                }
                else
                {
                    min2 = min1;
                    min1 = x;
                }
            }
        }
        if ( x > max3 )
        {
            if ( x <= max2 )
            {
                max3 = x;
            }
            else
            {
                max3 = max2;
                if ( x <= max1 )
                {
                    max2 = x;
                }
                else
                {
                    max2 = max1;
                    max1 = x;
                }
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x10(%rbp), %rax
addss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x19050
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movb %dl, -0x28(%rbp)
movsd -0x18(%rbp), %xmm1
movss 0x30(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x183e1
movq -0x38(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movss 0x34(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1838b
movq -0x38(%rbp), %rax
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x30(%rax)
jmp 0x183df
movq -0x38(%rbp), %rax
movss 0x34(%rax), %xmm0
movss %xmm0, 0x30(%rax)
movsd -0x18(%rbp), %xmm0
movss 0x38(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x183c1
movq -0x38(%rbp), %rax
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x34(%rax)
jmp 0x183dd
movq -0x38(%rbp), %rax
movss 0x38(%rax), %xmm0
movss %xmm0, 0x34(%rax)
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x38(%rax)
jmp 0x183df
jmp 0x183e1
movq -0x38(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movss 0x4c(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1847f
movq -0x38(%rbp), %rax
movsd -0x18(%rbp), %xmm1
movss 0x48(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x18429
movq -0x38(%rbp), %rax
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4c(%rax)
jmp 0x1847d
movq -0x38(%rbp), %rax
movss 0x48(%rax), %xmm0
movss %xmm0, 0x4c(%rax)
movsd -0x18(%rbp), %xmm1
movss 0x44(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jb 0x1845f
movq -0x38(%rbp), %rax
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x48(%rax)
jmp 0x1847b
movq -0x38(%rbp), %rax
movss 0x44(%rax), %xmm0
movss %xmm0, 0x48(%rax)
movsd -0x18(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x44(%rax)
jmp 0x1847d
jmp 0x1847f
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: probonopd[P]decodeir/./DecodeIR.h
// Function: setBurst::findMid()
void findMid()
    {
        iterator it = begin();
        iterator limit = end();
        float x = (*it);
        mid1 = x;
        mid2 = x;
        float m = 0;
        while ( ++it != limit )
        {
            float y = (*it);
            float z = y-x;
            if ( z > m )
            {
                m = z;
                mid1 = x;
                mid2 = y;
            }
            x = y;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x19850
movq -0x30(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x19880
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x198b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movss (%rcx), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x3c(%rax)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x40(%rax)
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x19900
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0x198d0
testb $0x1, %al
jne 0x1850a
jmp 0x18564
leaq -0x10(%rbp), %rdi
callq 0x198b0
movss (%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
subss -0x1c(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
ucomiss -0x20(%rbp), %xmm0
jbe 0x18558
movq -0x30(%rbp), %rax
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x3c(%rax)
movss -0x24(%rbp), %xmm0
movss %xmm0, 0x40(%rax)
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
jmp 0x184ef
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: probonopd[P]decodeir/./DecodeIR.h
// Function: Signal::lead_in(float, float, float, float, float)
int lead_in(float minTot, float maxTot, float maxOn, float minOff, float minFrameInc)
	{
        if (pLead)
        {
            if ( pLead[1] >= minOff && pLead[0] <= maxOn )
            {
                float t = pLead[0] + pLead[1];
                if ( t >= minTot && t <= maxTot && nFrame1 >= t+minFrameInc )
                    return 1;
            }
            if (pLead2)
            {
                if ( pLead2[1] >= minOff && pLead2[0] <= maxOn )
                {
                    float t = pLead2[0] + pLead2[1];
                    if ( t >= minTot && t <= maxTot && nFrame2 >= t+minFrameInc )
                        return 1;
                }
            }
        }
        return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movss %xmm2, -0x1c(%rbp)
movss %xmm3, -0x20(%rbp)
movss %xmm4, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0xd0(%rax)
je 0x18a1e
movq -0x38(%rbp), %rax
movq 0xd0(%rax), %rax
movss 0x4(%rax), %xmm0
ucomiss -0x20(%rbp), %xmm0
jb 0x18979
movq -0x38(%rbp), %rax
movq 0xd0(%rax), %rax
movss (%rax), %xmm1
movss -0x1c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jb 0x18979
movq -0x38(%rbp), %rax
movq 0xd0(%rax), %rcx
movss (%rcx), %xmm0
movq 0xd0(%rax), %rax
addss 0x4(%rax), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
ucomiss -0x14(%rbp), %xmm0
jb 0x18977
movss -0x28(%rbp), %xmm1
movss -0x18(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jb 0x18977
movq -0x38(%rbp), %rax
movss 0x134(%rax), %xmm0
movss -0x28(%rbp), %xmm1
addss -0x24(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jb 0x18977
movl $0x1, -0x4(%rbp)
jmp 0x18a25
jmp 0x18979
movq -0x38(%rbp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x18a1c
movq -0x38(%rbp), %rax
movq 0xd8(%rax), %rax
movss 0x4(%rax), %xmm0
ucomiss -0x20(%rbp), %xmm0
jb 0x18a1a
movq -0x38(%rbp), %rax
movq 0xd8(%rax), %rax
movss (%rax), %xmm1
movss -0x1c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jb 0x18a1a
movq -0x38(%rbp), %rax
movq 0xd8(%rax), %rcx
movss (%rcx), %xmm0
movq 0xd8(%rax), %rax
addss 0x4(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
ucomiss -0x14(%rbp), %xmm0
jb 0x18a18
movss -0x2c(%rbp), %xmm1
movss -0x18(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jb 0x18a18
movq -0x38(%rbp), %rax
movss 0x138(%rax), %xmm0
movss -0x2c(%rbp), %xmm1
addss -0x24(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jb 0x18a18
movl $0x1, -0x4(%rbp)
jmp 0x18a25
jmp 0x18a1a
jmp 0x18a1c
jmp 0x18a1e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: probonopd[P]decodeir/./DecodeIR.h
// Function: parity(unsigned int)
inline unsigned int parity(unsigned int p)
{
    unsigned int x = p ^ (p>>16);
    x = x ^ (x >> 8);
    x = x ^ (x >> 4);
    x = x ^ (x >> 2);
    return ( x ^ (x >> 1) ) & 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x4(%rbp), %ecx
shrl $0x10, %ecx
xorl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl -0x8(%rbp), %ecx
shrl $0x8, %ecx
xorl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl -0x8(%rbp), %ecx
shrl $0x4, %ecx
xorl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl -0x8(%rbp), %ecx
shrl $0x2, %ecx
xorl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl -0x8(%rbp), %ecx
shrl %ecx
xorl %ecx, %eax
andl $0x1, %eax
popq %rbp
retq
nop
// File: probonopd[P]decodeir/./DecodeIR.h
// Function: setBurst::clearF()
void clearF()
    {
        min3 = 1e9;
        min2 = 1e9;
        min1 = 1e9;
        max1 = 0;
        max2 = 0;
        max3 = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0x1464(%rip), %xmm0     # 0x1a008
movss %xmm0, 0x30(%rax)
movss 0x1457(%rip), %xmm0     # 0x1a008
movss %xmm0, 0x34(%rax)
movss 0x144a(%rip), %xmm0     # 0x1a008
movss %xmm0, 0x38(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x44(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x48(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x4c(%rax)
popq %rbp
retq
nopl (%rax)
// File: Dalgona[P]mine/mine.cpp
// Function: initColors()
void initColors(void)
{
  init_pair(11, 255, 0);    // white on black
  init_pair(12, 234, 234);  // menu unselected
  init_pair(13, 82, 82);    // menu selected
  init_pair(14, 123, 0);    // leaderboard title
  init_pair(15, 82, 0);     // beginner
  init_pair(16, 172, 0);    // intermediate
  init_pair(17, 198, 0);    // expert
  init_pair(18, 227, 0);    // name title 1
  init_pair(19, 214, 0);    // name title 2
  init_pair(20, 227, 0);    // 1st
  init_pair(21, 254, 0);    // 2nd
  init_pair(22, 178, 0);    // 3rd
  init_pair(23, 243, 0);    // 4th
  init_pair(24, 243, 0);    // 5th
  init_pair(30, 238, 234);  // name blank
  init_pair(31, 123, 17);   // name char
}

// Assembly:
pushq %rax
movl $0xb, %edi
movl $0xff, %esi
xorl %edx, %edx
callq 0x2070
movl $0xc, %edi
movl $0xea, %edx
movl %edx, %esi
callq 0x2070
movl $0xd, %edi
movl $0x52, %edx
movl %edx, %esi
callq 0x2070
movl $0xe, %edi
movl $0x7b, %esi
xorl %edx, %edx
callq 0x2070
movl $0xf, %edi
movl $0x52, %esi
xorl %edx, %edx
callq 0x2070
movl $0x10, %edi
movl $0xac, %esi
xorl %edx, %edx
callq 0x2070
movl $0x11, %edi
movl $0xc6, %esi
xorl %edx, %edx
callq 0x2070
movl $0x12, %edi
movl $0xe3, %esi
xorl %edx, %edx
callq 0x2070
movl $0x13, %edi
movl $0xd6, %esi
xorl %edx, %edx
callq 0x2070
movl $0x14, %edi
movl $0xe3, %esi
xorl %edx, %edx
callq 0x2070
movl $0x15, %edi
movl $0xfe, %esi
xorl %edx, %edx
callq 0x2070
movl $0x16, %edi
movl $0xb2, %esi
xorl %edx, %edx
callq 0x2070
movl $0x17, %edi
movl $0xf3, %esi
xorl %edx, %edx
callq 0x2070
movl $0x18, %edi
movl $0xf3, %esi
xorl %edx, %edx
callq 0x2070
movl $0x1e, %edi
movl $0xee, %esi
movl $0xea, %edx
callq 0x2070
movl $0x1f, %edi
movl $0x7b, %esi
movl $0x11, %edx
callq 0x2070
popq %rax
retq
nopl (%rax)
// File: Dalgona[P]mine/game.cpp
// Function: game::initColors()
void game::initColors()
{
  init_pair(1, 255, 0);      // Guide text
  init_pair(2, 197, 0);      // Game over message
  init_pair(3, 118, 0);      // Game cleared message
  init_pair(4, 86, 0);       // New game message
  /* pairs 11~100 are reserved */
  init_pair(101, 21, 250);   // Number 1
  init_pair(102, 22, 250);   // Number 2
  init_pair(103, 88, 250);   // Number 3
  init_pair(104, 18, 250);   // Number 4
  init_pair(105, 100, 250);  // Number 5
  init_pair(106, 24, 250);   // Number 6
  init_pair(107, 240, 250);  // Number 7
  init_pair(108, 240, 250);  // Number 8
  init_pair(109, 240, 250);  // Number 9
  init_pair(200, 250, 253);  // Unexplored
  init_pair(201, 196, 253);  // Flag
  init_pair(202, 235, 253);  // Question
  init_pair(203, 250, 250);  // Blank
  init_pair(204, 226, 202);  // Explosion
  init_pair(205, 235, 28);   // Correct
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movl $0x1, %edi
movl $0xff, %esi
xorl %edx, %edx
callq 0x2070
movl $0x2, %edi
movl $0xc5, %esi
xorl %edx, %edx
callq 0x2070
movl $0x3, %edi
movl $0x76, %esi
xorl %edx, %edx
callq 0x2070
movl $0x4, %edi
movl $0x56, %esi
xorl %edx, %edx
callq 0x2070
movl $0x65, %edi
movl $0x15, %esi
movl $0xfa, %edx
callq 0x2070
movl $0x66, %edi
movl $0x16, %esi
movl $0xfa, %edx
callq 0x2070
movl $0x67, %edi
movl $0x58, %esi
movl $0xfa, %edx
callq 0x2070
movl $0x68, %edi
movl $0x12, %esi
movl $0xfa, %edx
callq 0x2070
movl $0x69, %edi
movl $0x64, %esi
movl $0xfa, %edx
callq 0x2070
movl $0x6a, %edi
movl $0x18, %esi
movl $0xfa, %edx
callq 0x2070
movl $0x6b, %edi
movl $0xf0, %esi
movl $0xfa, %edx
callq 0x2070
movl $0x6c, %edi
movl $0xf0, %esi
movl $0xfa, %edx
callq 0x2070
movl $0x6d, %edi
movl $0xf0, %esi
movl $0xfa, %edx
callq 0x2070
movl $0xc8, %edi
movl $0xfa, %esi
movl $0xfd, %edx
callq 0x2070
movl $0xc9, %edi
movl $0xc4, %esi
movl $0xfd, %edx
callq 0x2070
movl $0xca, %edi
movl $0xeb, %esi
movl $0xfd, %edx
callq 0x2070
movl $0xcb, %edi
movl $0xfa, %edx
movl %edx, %esi
callq 0x2070
movl $0xcc, %edi
movl $0xe2, %esi
movl $0xca, %edx
callq 0x2070
movl $0xcd, %edi
movl $0xeb, %esi
movl $0x1c, %edx
callq 0x2070
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: Dalgona[P]mine/game.cpp
// Function: game::setFlag()
void game::setFlag()
{
  int &cp = field[index(cY, cX)];

  if (cp & MF_DISP_UNKNOWN)
  {
    cp &= ~MF_DISP_UNKNOWN;
    cp |= MF_DISP_FLAG;
    nFlags++;
  }
  else if (cp & MF_DISP_QUESTION)
  {
    cp &= ~MF_DISP_QUESTION;
    cp |= MF_DISP_FLAG;
    nFlags++;
  }
  else if (cp & MF_DISP_FLAG)
  {
    cp &= ~MF_DISP_FLAG;
    cp |= MF_DISP_UNKNOWN;
    nFlags--;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movl 0x28(%rdi), %esi
movl 0x2c(%rdi), %edx
callq 0xcfd0
movq 0x10(%rsp), %rdi
movslq %eax, %rsi
callq 0xe400
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0xc83e
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %edx
andl $0xfffeffff, %edx       # imm = 0xFFFEFFFF
movl %edx, (%rcx)
movq 0x18(%rsp), %rcx
movl (%rcx), %edx
orl $0x40000, %edx          # imm = 0x40000
movl %edx, (%rcx)
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
jmp 0xc8be
movq 0x18(%rsp), %rax
movl (%rax), %eax
andl $0x80000, %eax          # imm = 0x80000
cmpl $0x0, %eax
je 0xc87d
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %edx
andl $0xfff7ffff, %edx       # imm = 0xFFF7FFFF
movl %edx, (%rcx)
movq 0x18(%rsp), %rcx
movl (%rcx), %edx
orl $0x40000, %edx          # imm = 0x40000
movl %edx, (%rcx)
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
jmp 0xc8bc
movq 0x18(%rsp), %rax
movl (%rax), %eax
andl $0x40000, %eax          # imm = 0x40000
cmpl $0x0, %eax
je 0xc8ba
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %edx
andl $0xfffbffff, %edx       # imm = 0xFFFBFFFF
movl %edx, (%rcx)
movq 0x18(%rsp), %rcx
movl (%rcx), %edx
orl $0x10000, %edx          # imm = 0x10000
movl %edx, (%rcx)
movl 0x34(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x34(%rax)
jmp 0xc8bc
jmp 0xc8be
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Dalgona[P]mine/screen.cpp
// Function: screen::enable()
void screen::enable()
{
  if (enabled) return;
  initscr();
  cbreak();
  noecho();
  keypad(stdscr, true);
  updateMaxYX();
  if (has_colors())
    start_color();
  enabled = true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, (%rax)
je 0x1102a
jmp 0x1106f
callq 0x2370
callq 0x20c0
callq 0x22d0
movq 0x8f98(%rip), %rax      # 0x19fd8
movq (%rax), %rdi
movl $0x1, %esi
callq 0x2100
movq 0x8(%rsp), %rdi
callq 0x11080
callq 0x23a0
testb $0x1, %al
jne 0x11062
jmp 0x11067
callq 0x2080
movq 0x8(%rsp), %rax
movb $0x1, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Dalgona[P]mine/screen.cpp
// Function: screen::mvprintw(int, int, char const*, ...)
void screen::mvprintw(int row, int col, const char *format, ...)
{
  va_list args;
  va_start(args, format);

  if (row < 0) row = rows + row;
  if (col < 0) col = cols + col;
  wmove(stdscr, row, col);
  vwprintw(stdscr, format, args);

  va_end(args);
}

// Assembly:
subq $0xf8, %rsp
testb %al, %al
je 0x1126f
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm3, 0x70(%rsp)
movaps %xmm4, 0x80(%rsp)
movaps %xmm5, 0x90(%rsp)
movaps %xmm6, 0xa0(%rsp)
movaps %xmm7, 0xb0(%rsp)
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rdi, 0xf0(%rsp)
movl %esi, 0xec(%rsp)
movl %edx, 0xe8(%rsp)
movq %rcx, 0xe0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xc0(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x100(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
cmpl $0x0, 0xec(%rsp)
jge 0x112ee
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
addl 0xec(%rsp), %eax
movl %eax, 0xec(%rsp)
cmpl $0x0, 0xe8(%rsp)
jge 0x1130e
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
addl 0xe8(%rsp), %eax
movl %eax, 0xe8(%rsp)
movq 0x8cc3(%rip), %rax      # 0x19fd8
movq %rax, (%rsp)
movq (%rax), %rdi
movl 0xec(%rsp), %esi
movl 0xe8(%rsp), %edx
callq 0x2270
movq (%rsp), %rax
movq (%rax), %rdi
movq 0xe0(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x2420
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/conf2img/conf2img.cpp
// Function: main
int
main(int argc, char **argv)
{
  // Initialize packages
  if (!R3InitGraphics()) exit(-1);

  // Check number of arguments
  if (!ParseArgs(argc, argv)) exit(1);

  // Read configuration
  if (!ReadConfiguration(input_configuration_filename)) exit(-1);

  // Read cameras
  if (input_camera_filename) {
    if (!ReadCameras(input_camera_filename)) exit(-1);
  }

  // Read mesh
  if (input_mesh_filename) {
    if (!ReadMesh(input_mesh_filename)) exit(-1);
  }

  // Write images for configuration cameras
  if (!WriteImages(output_image_directory)) return 0;

  // Render images
  if (!RenderImages(output_image_directory)) exit(-1);
  
  // Return success 
  return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
callq 0x4e440
cmpl $0x0, %eax
jne 0x290a9
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x24c70
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x29180
cmpl $0x0, %eax
jne 0x290c6
movl $0x1, %edi
callq 0x24c70
movq 0x22cc9b(%rip), %rdi    # 0x255d68
callq 0x29b40
cmpl $0x0, %eax
jne 0x290e1
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x24c70
cmpq $0x0, 0x22cc87(%rip)    # 0x255d70
je 0x29108
movq 0x22cc7e(%rip), %rdi    # 0x255d70
callq 0x29d00
cmpl $0x0, %eax
jne 0x29106
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x24c70
jmp 0x29108
cmpq $0x0, 0x22cc68(%rip)    # 0x255d78
je 0x2912f
movq 0x22cc5f(%rip), %rdi    # 0x255d78
callq 0x2a100
cmpl $0x0, %eax
jne 0x2912d
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x24c70
jmp 0x2912f
movq 0x22cc4a(%rip), %rdi    # 0x255d80
callq 0x2a1f0
cmpl $0x0, %eax
jne 0x2914a
movl $0x0, 0x14(%rsp)
jmp 0x2916d
movq 0x22cc2f(%rip), %rdi    # 0x255d80
callq 0x2bc10
cmpl $0x0, %eax
jne 0x29165
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x24c70
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/conf2img/conf2img.cpp
// Function: ReadMesh(char const*)
static int
ReadMesh(const char *filename)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Read mesh from file
  if (!mesh.ReadFile(filename)) return 0;

  // Print statistics
  if (print_verbose) {
    printf("Read mesh ...\n");
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Faces = %d\n", mesh.NFaces());
    printf("  # Edges = %d\n", mesh.NEdges());
    printf("  # Vertices = %d\n", mesh.NVertices());
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x13fe80
leaq 0x8(%rsp), %rdi
callq 0x30490
movq 0x18(%rsp), %rsi
leaq 0x22bb07(%rip), %rdi    # 0x255c30
callq 0xcf140
cmpl $0x0, %eax
jne 0x2a140
movl $0x0, 0x24(%rsp)
jmp 0x2a1de
cmpl $0x0, 0x22bc41(%rip)    # 0x255d88
je 0x2a1d6
leaq 0x1b5310(%rip), %rdi    # 0x1df464
movb $0x0, %al
callq 0x24090
leaq 0x8(%rsp), %rdi
callq 0x13ff40
leaq 0x1b5271(%rip), %rdi    # 0x1df3dd
movb $0x1, %al
callq 0x24090
leaq 0x22bab6(%rip), %rdi    # 0x255c30
callq 0x30660
movl %eax, %esi
leaq 0x1b52eb(%rip), %rdi    # 0x1df473
movb $0x0, %al
callq 0x24090
leaq 0x22ba9a(%rip), %rdi    # 0x255c30
callq 0x30680
movl %eax, %esi
leaq 0x1b52df(%rip), %rdi    # 0x1df483
movb $0x0, %al
callq 0x24090
leaq 0x22ba7e(%rip), %rdi    # 0x255c30
callq 0x306a0
movl %eax, %esi
leaq 0x1b52d3(%rip), %rdi    # 0x1df493
movb $0x0, %al
callq 0x24090
movq 0x224dc2(%rip), %rax    # 0x24ef90
movq (%rax), %rdi
callq 0x24c10
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/conf2img/conf2img.cpp
// Function: RenderImages(char const*)
static int
RenderImages(const char *output_image_directory)
{
  // Check parameters
  if (!capture_color_images && !capture_depth_images &&
      !capture_mesh_color_images && !capture_mesh_depth_images &&
      !capture_mesh_position_images && !capture_mesh_wposition_images &&
      !capture_mesh_normal_images && !capture_mesh_wnormal_images && !capture_mesh_ndotv_images &&
      !capture_mesh_face_images && !capture_mesh_material_images &&
      !capture_mesh_segment_images && !capture_mesh_category_images) return 1;

  // Create output directory
  char cmd[1024];
  sprintf(cmd, "mkdir -p %s", output_image_directory);
  system(cmd);

  // Render images
  if (glut) { if (!RenderImagesWithGlut(output_image_directory)) return 0; }
  else if (mesa) { if (!RenderImagesWithMesa(output_image_directory)) return 0; }
  else { RNAbort("Not implemented"); }

  // Return success
  return 1;
}

// Assembly:
subq $0x418, %rsp            # imm = 0x418
movq %rdi, 0x408(%rsp)
cmpl $0x0, 0x22a1ae(%rip)    # 0x255dd4
jne 0x2bca4
cmpl $0x0, 0x22a1a9(%rip)    # 0x255dd8
jne 0x2bca4
cmpl $0x0, 0x22a1a4(%rip)    # 0x255ddc
jne 0x2bca4
cmpl $0x0, 0x22a19f(%rip)    # 0x255de0
jne 0x2bca4
cmpl $0x0, 0x22a19a(%rip)    # 0x255de4
jne 0x2bca4
cmpl $0x0, 0x22a195(%rip)    # 0x255de8
jne 0x2bca4
cmpl $0x0, 0x22a190(%rip)    # 0x255dec
jne 0x2bca4
cmpl $0x0, 0x22a18b(%rip)    # 0x255df0
jne 0x2bca4
cmpl $0x0, 0x22a186(%rip)    # 0x255df4
jne 0x2bca4
cmpl $0x0, 0x22a181(%rip)    # 0x255df8
jne 0x2bca4
cmpl $0x0, 0x22a17c(%rip)    # 0x255dfc
jne 0x2bca4
cmpl $0x0, 0x22a177(%rip)    # 0x255e00
jne 0x2bca4
cmpl $0x0, 0x22a172(%rip)    # 0x255e04
jne 0x2bca4
movl $0x1, 0x414(%rsp)
jmp 0x2bd34
movq %rsp, %rdi
movq 0x408(%rsp), %rdx
leaq 0x1b380a(%rip), %rsi    # 0x1df4c0
movb $0x0, %al
callq 0x24160
movq %rsp, %rdi
callq 0x24870
cmpl $0x0, 0x223dd4(%rip)    # 0x24faa0
je 0x2bcef
movq 0x408(%rsp), %rdi
callq 0x2c4d0
cmpl $0x0, %eax
jne 0x2bced
movl $0x0, 0x414(%rsp)
jmp 0x2bd34
jmp 0x2bd29
cmpl $0x0, 0x22a09a(%rip)    # 0x255d90
je 0x2bd19
movq 0x408(%rsp), %rdi
callq 0x2c590
cmpl $0x0, %eax
jne 0x2bd17
movl $0x0, 0x414(%rsp)
jmp 0x2bd34
jmp 0x2bd27
leaq 0x1b391b(%rip), %rdi    # 0x1df63b
movb $0x0, %al
callq 0x144cf0
jmp 0x2bd29
movl $0x1, 0x414(%rsp)
movl 0x414(%rsp), %eax
addq $0x418, %rsp            # imm = 0x418
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/conf2img/conf2img.cpp
// Function: IsFaceCompatible(gaps::R3Point const&, gaps::R3Vector const&, gaps::R3Mesh*, gaps::R3MeshFace*, void*)
static int
IsFaceCompatible(const R3Point& query_position, const R3Vector& query_normal, R3Mesh *mesh, R3MeshFace *face, void *data)
{
  // Check if should skip face
  if (skip_removed_faces) {
    // This is a hack to skip faces marked for removal in the matterport dataset
    int category_index = mesh->FaceCategory(face);
    if (category_index == 9) return 0;
    if (category_index == 64) return 0;
  }

#if 0
  // Check normal compatibility
  R3Vector face_normal = mesh->FaceNormal(face);
  if (face_normal.Dot(query_normal) < 0) return 0;
#endif

  // Passed all tests
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
cmpl $0x0, 0x229910(%rip)    # 0x255d94
je 0x2c4bd
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x30950
movl %eax, 0x4(%rsp)
cmpl $0x9, 0x4(%rsp)
jne 0x2c4aa
movl $0x0, 0x34(%rsp)
jmp 0x2c4c5
cmpl $0x40, 0x4(%rsp)
jne 0x2c4bb
movl $0x0, 0x34(%rsp)
jmp 0x2c4c5
jmp 0x2c4bd
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop