LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::remap_constexpr_sampler(unsigned int, spirv_cross::MSLConstexprSampler const&)
void CompilerMSL::remap_constexpr_sampler(uint32_t id, const MSLConstexprSampler &sampler)
{
	auto &type = get<SPIRType>(get<SPIRVariable>(id).basetype);
	if (type.basetype != SPIRType::SampledImage && type.basetype != SPIRType::Sampler)
		SPIRV_CROSS_THROW("Can only remap SampledImage and Sampler type.");
	if (!type.array.empty())
		SPIRV_CROSS_THROW("Can not remap array of samplers.");
	constexpr_samplers[id] = sampler;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl -0xc(%rbp), %esi
callq 0xfec0
movq -0x88(%rbp), %rdi
movl 0xc(%rax), %esi
callq 0xea90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xe, 0xc(%rax)
je 0x10e850
movq -0x20(%rbp), %rax
cmpl $0xf, 0xc(%rax)
je 0x10e850
movb $0x1, -0x55(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x98(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x7650
movq -0x90(%rbp), %rdx
leaq 0x3f377(%rip), %rsi     # 0x14db42
leaq -0x40(%rbp), %rdi
callq 0x7520
jmp 0x10e7d6
movq -0x98(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x9c50
jmp 0x10e7e8
movq -0x98(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x9f5de(%rip), %rsi     # 0x1addd8
leaq -0x104b71(%rip), %rdx   # 0x9c90
callq 0x7610
jmp 0x10e962
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x10e82e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7708
leaq -0x41(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x55(%rbp)
jne 0x10e83f
jmp 0x10e84b
movq -0x98(%rbp), %rdi
callq 0x72c0
jmp 0x10e959
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x8690
testb $0x1, %al
jne 0x10e91a
movb $0x1, -0x7a(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0xa8(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x7650
movq -0xa0(%rbp), %rdx
leaq 0x3f2d8(%rip), %rsi     # 0x14db70
leaq -0x78(%rbp), %rdi
callq 0x7520
jmp 0x10e8a3
movq -0xa8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x9c50
jmp 0x10e8b5
movq -0xa8(%rbp), %rdi
movb $0x0, -0x7a(%rbp)
leaq 0x9f511(%rip), %rsi     # 0x1addd8
leaq -0x104c3e(%rip), %rdx   # 0x9c90
callq 0x7610
jmp 0x10e962
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x10e8fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x7708
leaq -0x79(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x7a(%rbp)
jne 0x10e90c
jmp 0x10e918
movq -0xa8(%rbp), %rdi
callq 0x72c0
jmp 0x10e959
movq -0x88(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
addq $0x9c8, %rdi            # imm = 0x9C8
leaq -0xc(%rbp), %rsi
callq 0x117e00
movq -0xb0(%rbp), %rsi
movq %rax, %rdi
movl $0x33, %edx
callq 0x72e0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::bitcast_from_builtin_load(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, spirv_cross::SPIRType const&)
void CompilerMSL::bitcast_from_builtin_load(uint32_t source_id, std::string &expr, const SPIRType &expr_type)
{
	auto *var = maybe_get_backing_variable(source_id);
	if (var)
		source_id = var->self;

	// Only interested in standalone builtin variables.
	if (!has_decoration(source_id, DecorationBuiltIn))
		return;

	auto builtin = static_cast<BuiltIn>(get_decoration(source_id, DecorationBuiltIn));
	auto expected_type = expr_type.basetype;
	switch (builtin)
	{
	case BuiltInGlobalInvocationId:
	case BuiltInLocalInvocationId:
	case BuiltInWorkgroupId:
	case BuiltInLocalInvocationIndex:
	case BuiltInWorkgroupSize:
	case BuiltInNumWorkgroups:
	case BuiltInLayer:
	case BuiltInViewportIndex:
		expected_type = SPIRType::UInt;
		break;

	default:
		break;
	}

	if (expected_type != expr_type.basetype)
		expr = bitcast_expression(expr_type, expected_type, expr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl -0xc(%rbp), %esi
callq 0x1fa90
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x10e9ac
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x58(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0xb, %edx
callq 0x1f560
testb $0x1, %al
jne 0x10e9c6
jmp 0x10ea46
movq -0x58(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0xb, %edx
callq 0x23520
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x5c(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x10ea01
jmp 0x10e9f4
movl -0x5c(%rbp), %eax
addl $-0x18, %eax
subl $0x5, %eax
ja 0x10ea0a
jmp 0x10ea01
movl $0x5, -0x30(%rbp)
jmp 0x10ea0c
jmp 0x10ea0c
movl -0x30(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0xc(%rcx), %eax
je 0x10ea46
movq -0x58(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x30(%rbp), %ecx
movq -0x18(%rbp), %r8
leaq -0x50(%rbp), %rdi
callq 0x7dfd0
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7430
leaq -0x50(%rbp), %rdi
callq 0x7708
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::bitcast_to_builtin_store(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, spirv_cross::SPIRType const&)
void CompilerMSL::bitcast_to_builtin_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type)
{
	// Only interested in standalone builtin variables.
	if (!has_decoration(target_id, DecorationBuiltIn))
		return;

	auto builtin = static_cast<BuiltIn>(get_decoration(target_id, DecorationBuiltIn));
	auto expected_type = expr_type.basetype;
	switch (builtin)
	{
	case BuiltInLayer:
	case BuiltInViewportIndex:
		expected_type = SPIRType::UInt;
		break;

	default:
		break;
	}

	if (expected_type != expr_type.basetype)
	{
		auto type = expr_type;
		type.basetype = expected_type;
		expr = bitcast_expression(type, expr_type.basetype, expr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x138(%rbp)
movl -0xc(%rbp), %esi
movl $0xb, %edx
callq 0x1f560
testb $0x1, %al
jne 0x10ea8b
jmp 0x10eb65
movq -0x138(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0xb, %edx
callq 0x23520
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $-0x9, %eax
subl $0x1, %eax
ja 0x10eac2
jmp 0x10eab9
movl $0x5, -0x28(%rbp)
jmp 0x10eac4
jmp 0x10eac4
movl -0x28(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0xc(%rcx), %eax
je 0x10eb65
movq -0x20(%rbp), %rsi
leaq -0x100(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x3d730
movq -0x138(%rbp), %rsi
movq -0x140(%rbp), %rdx
movl -0x28(%rbp), %eax
movl %eax, -0xf4(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x18(%rbp), %r8
leaq -0x120(%rbp), %rdi
callq 0x7dfd0
jmp 0x10eb1b
movq -0x18(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x7430
leaq -0x120(%rbp), %rdi
callq 0x7708
leaq -0x100(%rbp), %rdi
callq 0x314e0
jmp 0x10eb65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x314e0
jmp 0x10eb6e
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x128(%rbp), %rdi
callq 0x7640
nopw (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_msl.cpp
// Function: spirv_cross::CompilerMSL::to_initializer_expression[abi:cxx11](spirv_cross::SPIRVariable const&)
std::string CompilerMSL::to_initializer_expression(const SPIRVariable &var)
{
	// We risk getting an array initializer here with MSL. If we have an array.
	// FIXME: We cannot handle non-constant arrays being initialized.
	// We will need to inject spvArrayCopy here somehow ...
	auto &type = get<SPIRType>(var.basetype);
	if (ir.ids[var.initializer].get_type() == TypeConstant &&
	    (!type.array.empty() || type.basetype == SPIRType::Struct))
		return constant_expression(get<SPIRConstant>(var.initializer));
	else
		return CompilerGLSL::to_initializer_expression(var);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0xea90
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %esi
callq 0xbdb0
movq %rax, %rdi
callq 0xfa00
cmpl $0x3, %eax
jne 0x10ec1d
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x8690
testb $0x1, %al
jne 0x10ebf1
jmp 0x10ebfb
movq -0x20(%rbp), %rax
cmpl $0xc, 0xc(%rax)
jne 0x10ec1d
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x31910
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x64bc0
jmp 0x10ec2e
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rdx
callq 0x95ff0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_parser.cpp
// Function: spirv_cross::is_valid_spirv_version(unsigned int)
static bool is_valid_spirv_version(uint32_t version)
{
	switch (version)
	{
	// Allow v99 since it tends to just work.
	case 99:
	case 0x10000: // SPIR-V 1.0
	case 0x10100: // SPIR-V 1.1
	case 0x10200: // SPIR-V 1.2
	case 0x10300: // SPIR-V 1.3
		return true;

	default:
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x63, %eax
je 0x12d1c4
jmp 0x12d194
movl -0xc(%rbp), %eax
subl $0x10000, %eax          # imm = 0x10000
je 0x12d1c4
jmp 0x12d1a0
movl -0xc(%rbp), %eax
subl $0x10100, %eax          # imm = 0x10100
je 0x12d1c4
jmp 0x12d1ac
movl -0xc(%rbp), %eax
subl $0x10200, %eax          # imm = 0x10200
je 0x12d1c4
jmp 0x12d1b8
movl -0xc(%rbp), %eax
subl $0x10300, %eax          # imm = 0x10300
jne 0x12d1ca
jmp 0x12d1c4
movb $0x1, -0x1(%rbp)
jmp 0x12d1ce
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_parser.cpp
// Function: spirv_cross::Parser::stream(spirv_cross::Instruction const&) const
const uint32_t *Parser::stream(const Instruction &instr) const
{
	// If we're not going to use any arguments, just return nullptr.
	// We want to avoid case where we return an out of range pointer
	// that trips debug assertions on some platforms.
	if (!instr.length)
		return nullptr;

	if (instr.offset + instr.length > ir.spirv.size())
		SPIRV_CROSS_THROW("Compiler::stream() out of range.");
	return &ir.spirv[instr.offset];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x130f4f
movq $0x0, -0x8(%rbp)
jmp 0x131032
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
addl 0x8(%rcx), %eax
movl %eax, %eax
movq %rax, -0x60(%rbp)
callq 0x8650
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jbe 0x13101c
movb $0x1, -0x4d(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x7650
movq -0x68(%rbp), %rdx
leaq 0xea92(%rip), %rsi      # 0x13fa38
leaq -0x38(%rbp), %rdi
callq 0x7520
jmp 0x130fb1
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9c50
jmp 0x130fc0
movq -0x70(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x7ce09(%rip), %rsi     # 0x1addd8
leaq -0x127346(%rip), %rdx   # 0x9c90
callq 0x7610
jmp 0x131045
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x131000
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7708
leaq -0x39(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x4d(%rbp)
jne 0x131011
jmp 0x13101a
movq -0x70(%rbp), %rdi
callq 0x72c0
jmp 0x13103c
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x8570
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_parser.cpp
// Function: spirv_cross::extract_string[abi:cxx11](std::vector<unsigned int, std::allocator<unsigned int>> const&, unsigned int)
static string extract_string(const vector<uint32_t> &spirv, uint32_t offset)
{
	string ret;
	for (uint32_t i = offset; i < spirv.size(); i++)
	{
		uint32_t w = spirv[i];

		for (uint32_t j = 0; j < 4; j++, w >>= 8)
		{
			char c = w & 0xff;
			if (c == '\0')
				return ret;
			ret += c;
		}
	}

	SPIRV_CROSS_THROW("String was not terminated before EOF");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x7530
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8650
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x13112d
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x8570
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jae 0x13111d
movl -0x20(%rbp), %eax
andl $0xff, %eax
movb %al, -0x25(%rbp)
movsbl -0x25(%rbp), %eax
cmpl $0x0, %eax
jne 0x1310e7
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x1311e2
jmp 0x1311d9
movq -0x70(%rbp), %rdi
movsbl -0x25(%rbp), %esi
callq 0x7220
jmp 0x1310f6
jmp 0x1310f8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x20(%rbp)
jmp 0x1310ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1311ef
jmp 0x13111f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x131080
movb $0x1, -0x5a(%rbp)
movl $0x10, %edi
callq 0x71a0
movq %rax, -0x88(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x7650
movq -0x80(%rbp), %rdx
leaq 0x1cff2(%rip), %rsi     # 0x14e14c
leaq -0x58(%rbp), %rdi
callq 0x7520
jmp 0x131165
movq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x9c50
jmp 0x131177
movq -0x88(%rbp), %rdi
movb $0x0, -0x5a(%rbp)
leaq 0x7cc4f(%rip), %rsi     # 0x1addd8
leaq -0x127500(%rip), %rdx   # 0x9c90
callq 0x7610
jmp 0x131201
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1311ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x7708
leaq -0x59(%rbp), %rdi
callq 0x73d0
testb $0x1, -0x5a(%rbp)
jne 0x1311cb
jmp 0x1311d7
movq -0x88(%rbp), %rdi
callq 0x72c0
jmp 0x1311ef
movq -0x70(%rbp), %rdi
callq 0x7708
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x7708
movq -0x30(%rbp), %rdi
callq 0x7640
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/SPIRV-Cross/spirv_parser.cpp
// Function: spirv_cross::Parser::variable_storage_is_aliased(spirv_cross::SPIRVariable const&) const
bool Parser::variable_storage_is_aliased(const SPIRVariable &v) const
{
	auto &type = get<SPIRType>(v.basetype);
	bool ssbo = v.storage == StorageClassStorageBuffer ||
	            ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock);
	bool image = type.basetype == SPIRType::Image;
	bool counter = type.basetype == SPIRType::AtomicCounter;

	bool is_restrict;
	if (ssbo)
		is_restrict = ir.get_buffer_block_flags(v).get(DecorationRestrict);
	else
		is_restrict = ir.has_decoration(v.self, DecorationRestrict);

	return !is_restrict && (ssbo || image || counter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x132520
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpl $0xc, 0x10(%rcx)
movb %al, -0x6d(%rbp)
je 0x1319a4
movq -0x78(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x2e6f0
movq %rax, %rdi
addq $0x60, %rdi
movl $0x3, %esi
callq 0xef50
movb %al, -0x6d(%rbp)
movb -0x6d(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xd, 0xc(%rax)
sete %al
andb $0x1, %al
movb %al, -0x1a(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x8, 0xc(%rax)
sete %al
andb $0x1, %al
movb %al, -0x1b(%rbp)
testb $0x1, -0x19(%rbp)
je 0x131a2a
movq -0x78(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x54c20
movq -0x88(%rbp), %rdi
movl $0x13, %esi
callq 0xef50
movb %al, -0x79(%rbp)
jmp 0x131a00
movb -0x79(%rbp), %al
andb $0x1, %al
movb %al, -0x1c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xf250
jmp 0x131a44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xf250
jmp 0x131a94
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movl $0x13, %edx
callq 0x54ed0
andb $0x1, %al
movb %al, -0x1c(%rbp)
xorl %eax, %eax
testb $0x1, -0x1c(%rbp)
movb %al, -0x89(%rbp)
jne 0x131a83
movb $0x1, %al
testb $0x1, -0x19(%rbp)
movb %al, -0x8a(%rbp)
jne 0x131a77
movb $0x1, %al
testb $0x1, -0x1a(%rbp)
movb %al, -0x8a(%rbp)
jne 0x131a77
movb -0x1b(%rbp), %al
movb %al, -0x8a(%rbp)
movb -0x8a(%rbp), %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x7640
nopl (%rax)
// File: rossy[P]crossc/crossc-glsl.cc
// Function: crossc_glsl_create
crossc_compiler *crossc_glsl_create(const uint32_t *words, size_t word_count)
{
	crossc_compiler *comp = new crossc_compiler;
	try {
		comp->c = std::make_unique<spirv_cross::CompilerGLSL>(words, word_count);
	} catch (const std::exception &e) {
		comp->error = std::string { e.what() };
	}
	return comp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x48, %edi
callq 0x7360
movq %rax, %rdi
movq %rdi, -0x68(%rbp)
callq 0x13cb00
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x13cb40
jmp 0x13c9a4
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x13cbd0
leaq -0x20(%rbp), %rdi
callq 0x13cc00
jmp 0x13ca41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x13ca6c
movq -0x28(%rbp), %rdi
callq 0x7150
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x78(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x7650
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x7520
jmp 0x13ca19
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
leaq -0x58(%rbp), %rsi
callq 0x7430
leaq -0x58(%rbp), %rdi
callq 0x7708
leaq -0x59(%rbp), %rdi
callq 0x73d0
callq 0x75e0
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x73d0
callq 0x75e0
jmp 0x13ca6a
jmp 0x13ca6c
movq -0x28(%rbp), %rdi
callq 0x7640
movq %rax, %rdi
callq 0x9240
nopl (%rax)
// File: rossy[P]crossc/crossc-glsl.cc
// Function: crossc_glsl_set_version
void crossc_glsl_set_version(crossc_compiler *comp, int version,
                             crossc_glsl_profile profile)
{
	if (!comp->c)
		return;
	auto glsl = comp->c.get();
	auto opts = glsl->get_common_options();
	opts.version = version;
	opts.es = (profile == CROSSC_GLSL_PROFILE_ES);
	glsl->set_common_options(opts);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13cc50
testb $0x1, %al
jne 0x13caa1
jmp 0x13caed
movq -0x8(%rbp), %rdi
callq 0x13cc80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13ccb0
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x1, -0x10(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13ccd0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: rossy[P]crossc/crossc-hlsl.cc
// Function: crossc_hlsl_create
crossc_compiler *crossc_hlsl_create(const uint32_t *words, size_t word_count)
{
	crossc_compiler *comp = new crossc_compiler;
	try {
		comp->c = std::make_unique<spirv_cross::CompilerHLSL>(words, word_count);
	} catch (const std::exception &e) {
		comp->error = std::string { e.what() };
	}
	return comp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x48, %edi
callq 0x7360
movq %rax, %rdi
movq %rdi, -0x68(%rbp)
callq 0x13cb00
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x13d3d0
jmp 0x13d274
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x13d460
leaq -0x20(%rbp), %rdi
callq 0x13d4c0
jmp 0x13d311
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x13d33c
movq -0x28(%rbp), %rdi
callq 0x7150
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x78(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x7650
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x7520
jmp 0x13d2e9
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
leaq -0x58(%rbp), %rsi
callq 0x7430
leaq -0x58(%rbp), %rdi
callq 0x7708
leaq -0x59(%rbp), %rdi
callq 0x73d0
callq 0x75e0
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x73d0
callq 0x75e0
jmp 0x13d33a
jmp 0x13d33c
movq -0x28(%rbp), %rdi
callq 0x7640
movq %rax, %rdi
callq 0x9240
nopl (%rax)
// File: rossy[P]crossc/crossc-hlsl.cc
// Function: crossc_hlsl_set_shader_model
void crossc_hlsl_set_shader_model(crossc_compiler *comp, int model)
{
	if (!comp->c)
		return;
	auto hlsl = get_hlsl(comp);
	auto opts = hlsl->get_hlsl_options();
	opts.shader_model = model;
	hlsl->set_hlsl_options(opts);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13cc50
testb $0x1, %al
jne 0x13d36e
jmp 0x13d39e
movq -0x8(%rbp), %rdi
callq 0x13d3b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13d520
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x13d540
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rossy[P]crossc/crossc.cc
// Function: crossc_set_flip_vert_y
void crossc_set_flip_vert_y(crossc_compiler *comp, bool flip_vert_y)
{
	if (!comp->c)
		return;
	auto opts = comp->c->get_common_options();
	opts.vertex.flip_vert_y = flip_vert_y;
	comp->c->set_common_options(opts);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13cc50
testb $0x1, %al
jne 0x13dbc3
jmp 0x13dc08
movq -0x8(%rbp), %rdi
callq 0x13dde0
movq %rax, %rdi
callq 0x13ccb0
movq (%rax), %rcx
movq %rcx, -0x24(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x1c(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x14(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13dde0
movq %rax, %rdi
leaq -0x24(%rbp), %rsi
callq 0x13ccd0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: rossy[P]crossc/crossc.cc
// Function: crossc_compile
const char *crossc_compile(crossc_compiler *comp)
{
	if (!comp->c)
		return nullptr;
	try {
		comp->output = comp->c->compile();
		return comp->output.c_str();
	} catch (const std::exception &e) {
		comp->error = std::string { e.what() };
		return nullptr;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13cc50
testb $0x1, %al
jne 0x13dc39
movq $0x0, -0x8(%rbp)
jmp 0x13dd2e
movq -0x10(%rbp), %rdi
callq 0x13dde0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x30(%rbp), %rdi
callq *%rax
jmp 0x13dc54
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x7430
leaq -0x30(%rbp), %rdi
callq 0x7708
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x7160
movq %rax, -0x8(%rbp)
jmp 0x13dd2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x13dd3b
movq -0x38(%rbp), %rdi
callq 0x7150
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x80(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x7650
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x7520
jmp 0x13dcde
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
leaq -0x68(%rbp), %rsi
callq 0x7430
leaq -0x68(%rbp), %rdi
callq 0x7708
leaq -0x69(%rbp), %rdi
callq 0x73d0
movq $0x0, -0x8(%rbp)
callq 0x75e0
jmp 0x13dd2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x73d0
callq 0x75e0
jmp 0x13dd2c
jmp 0x13dd3b
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x7640
movq %rax, %rdi
callq 0x9240
nopl (%rax)
// File: halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::default_parser<int>::operator()(char const*) const
maybe<V> operator()(const char* text) const {
        if (!text) return nothing;
        V v;
        std::istringstream stream(text);
        if (!(stream >> v)) return nothing;
        if (!stream.eof()) stream >> std::ws;
        return stream.eof()? maybe<V>(v): nothing;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x1f0(%rbp)
movq %rdi, %rax
movq %rax, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7450
movq -0x1f0(%rbp), %rdi
callq 0x76e0
jmp 0x7628
movq -0x18(%rbp), %rax
movq %rax, -0x200(%rbp)
leaq -0x1c1(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0x3380
movq -0x200(%rbp), %rsi
movq -0x1f8(%rbp), %rdx
leaq -0x1c0(%rbp), %rdi
callq 0x4de0
jmp 0x748a
leaq -0x1a0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
movl $0x8, %edx
callq 0x3340
jmp 0x74a4
leaq -0x1c0(%rbp), %rdi
callq 0x3160
leaq -0x1c1(%rbp), %rdi
callq 0x3240
leaq -0x1a0(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3150
movq %rax, -0x208(%rbp)
jmp 0x74d5
movq -0x208(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x30e0
movb %al, -0x209(%rbp)
jmp 0x74f3
movb -0x209(%rbp), %al
testb $0x1, %al
jne 0x7502
jmp 0x7583
movq -0x1f0(%rbp), %rdi
callq 0x76e0
movl $0x1, -0x1dc(%rbp)
jmp 0x761c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0x754f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3160
leaq -0x1c1(%rbp), %rdi
callq 0x3240
jmp 0x7638
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x30f0
jmp 0x7638
movq -0x1a0(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1a0(%rbp,%rax), %rdi
callq 0x33a0
movb %al, -0x20a(%rbp)
jmp 0x75a3
movb -0x20a(%rbp), %al
testb $0x1, %al
jne 0x75c6
jmp 0x75af
movq 0x13a12(%rip), %rsi     # 0x1afc8
leaq -0x1a0(%rbp), %rdi
callq 0x3070
jmp 0x75c4
jmp 0x75c6
movq -0x1a0(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1a0(%rbp,%rax), %rdi
callq 0x33a0
movb %al, -0x20b(%rbp)
jmp 0x75e6
movb -0x20b(%rbp), %al
testb $0x1, %al
jne 0x75f2
jmp 0x7606
movq -0x1f0(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7700
jmp 0x7604
jmp 0x7612
movq -0x1f0(%rbp), %rdi
callq 0x76e0
movl $0x1, -0x1dc(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x30f0
movq -0x1e8(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1d0(%rbp), %rdi
callq 0x3370
nopw %cs:(%rax,%rax)
nop
// File: halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::keyword_parser<int>::operator()(char const*) const
maybe<V> operator()(const char* text) const {
        if (!text) return nothing;
        for (const auto& p: map_) {
            if (text==p.first) return p.second;
        }
        return nothing;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9209
movq -0x60(%rbp), %rdi
callq 0x76e0
jmp 0x9287
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8a30
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8a60
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8c50
testb $0x1, %al
jne 0x923e
jmp 0x927e
leaq -0x30(%rbp), %rdi
callq 0x8cc0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x92a0
testb $0x1, %al
jne 0x925e
jmp 0x9271
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x20, %rsi
callq 0x7700
jmp 0x9287
jmp 0x9273
leaq -0x30(%rbp), %rdi
callq 0x8ce0
jmp 0x922b
movq -0x60(%rbp), %rdi
callq 0x76e0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: atohex(char*)
u32 atohex(char *s)
{
u32 val;

   // return 32-bit integer value of a hex ascii string (can have leading 0x)

   if(s == 0) return 0;
   if((s[0] == '0') && (s[1] == 'x')) s += 2;
   else if((s[0] == '0') && (s[1] == 'X')) s += 2;

   val = 0;
   sscanf(s, "%x", &val);
   return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x98ec
movl $0x0, -0x4(%rbp)
jmp 0x995d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x9913
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x78, %eax
jne 0x9913
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
jmp 0x993a
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x9938
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x58, %eax
jne 0x9938
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
jmp 0x993a
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x17acbd(%rip), %rsi    # 0x184609
leaq -0x14(%rbp), %rdx
movb $0x0, %al
callq 0x9370
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: atosecs(char*)
double atosecs(char *s)
{
double val;

   // return integer value of a hex ascii string
   if(s == 0) return 0;

   val = 0;
   val = atof(s);

   if(strchr(s, 'm') || strchr(s, 'M')) val *= 60.0;
   else if(strchr(s, 'h') || strchr(s, 'H')) val *= 60.0*60.0;
   else if(strchr(s, 'd') || strchr(s, 'D')) val *= 24.0*60.0*60.0;

   return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9990
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x9a66
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9480
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x6d, %esi
callq 0x9100
cmpq $0x0, %rax
jne 0x99ce
movq -0x10(%rbp), %rdi
movl $0x4d, %esi
callq 0x9100
cmpq $0x0, %rax
je 0x99e2
movsd 0x165642(%rip), %xmm0   # 0x16f018
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x9a5c
movq -0x10(%rbp), %rdi
movl $0x68, %esi
callq 0x9100
cmpq $0x0, %rax
jne 0x9a0a
movq -0x10(%rbp), %rdi
movl $0x48, %esi
callq 0x9100
cmpq $0x0, %rax
je 0x9a1e
movsd 0x1655fe(%rip), %xmm0   # 0x16f010
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x9a5a
movq -0x10(%rbp), %rdi
movl $0x64, %esi
callq 0x9100
cmpq $0x0, %rax
jne 0x9a46
movq -0x10(%rbp), %rdi
movl $0x44, %esi
callq 0x9100
cmpq $0x0, %rax
je 0x9a58
movsd 0x1655ba(%rip), %xmm0   # 0x16f008
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x9a5a
jmp 0x9a5c
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: tune_exists(char*, int)
int tune_exists(char *file, int add_path)
{
char tune[MAX_PATH+1];
FILE *f;

   // This routine sees if a sound file exists

   if(add_path) sprintf(tune, "%s%s", heather_path, file);
   else         sprintf(tune, "%s", file);

   f = topen(tune, "r");
   if(f) {
      fclose(f);
      return 1;
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x9aba
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rcx
leaq 0x167ae0(%rip), %rsi    # 0x17158a
leaq 0x1c63bf(%rip), %rdx    # 0x1cfe70
movb $0x0, %al
callq 0x9060
jmp 0x9ad3
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x187061(%rip), %rsi    # 0x190b2d
movb $0x0, %al
callq 0x9060
leaq -0x120(%rbp), %rdi
leaq 0x17a52c(%rip), %rsi    # 0x18400d
callq 0x9b20
movq %rax, -0x128(%rbp)
cmpq $0x0, -0x128(%rbp)
je 0x9b0c
movq -0x128(%rbp), %rdi
callq 0x9380
movl $0x1, -0x4(%rbp)
jmp 0x9b13
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heather.cpp
// Function: topen(char*, char*)
FILE *topen(char *fn, char *m)
{
char *f;

   // open a file,  trim leading whitespace from the name
   if(m == 0) return 0;
   f = trim_whitespace(fn);
   if(f == 0) return 0;

if(show_debug_info) printf("topen(%s, %s)\n", f,m);  //zorky
   return path_open(f, m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9b41
movq $0x0, -0x8(%rbp)
jmp 0x9b8f
movq -0x10(%rbp), %rdi
callq 0xa150
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9b5f
movq $0x0, -0x8(%rbp)
jmp 0x9b8f
cmpb $0x0, 0x26df3e(%rip)    # 0x277aa4
je 0x9b7e
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x165aa5(%rip), %rdi    # 0x16f61c
movb $0x0, %al
callq 0x9030
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa4e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: play_tune(char*, int)
void play_tune(char *file, int add_path)
{
char tune[MAX_PATH+1];

   // This routine plays a sound file asynchronously (non-blocking)

   if(!sound_on) return;

   if(add_path) sprintf(tune, "%s%s", heather_path, file);
   else         sprintf(tune, "%s", file);


   #ifdef WINDOWS
      PlaySoundA(tune, NULL, SND_ASYNC);
   #endif

   #ifdef __linux__
      if(no_exec > 1) return;
      char shell_cmd[MAX_PATH+64];
      sprintf(shell_cmd, "/bin/sh -c \"aplay -q %s\" &", tune);
      system(shell_cmd);
   #endif

   #ifdef __MACH__
      if(no_exec > 1) return;
      char shell_cmd[MAX_PATH+64];
      sprintf(shell_cmd, "afplay %s &", tune);
      system(shell_cmd);
   #endif

   #ifdef __FreeBSD__
      //  FreeBSD does not have a standard sound system
   #endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpb $0x0, 0x27080f(%rip)    # 0x27a608
jne 0x9dfd
jmp 0x9e71
cmpl $0x0, -0xc(%rbp)
je 0x9e25
leaq -0x110(%rbp), %rdi
movq -0x8(%rbp), %rcx
leaq 0x167775(%rip), %rsi    # 0x17158a
leaq 0x1c6054(%rip), %rdx    # 0x1cfe70
movb $0x0, %al
callq 0x9060
jmp 0x9e3e
leaq -0x110(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x186cf6(%rip), %rsi    # 0x190b2d
movb $0x0, %al
callq 0x9060
cmpl $0x1, 0x36344f(%rip)    # 0x36d294
jle 0x9e49
jmp 0x9e71
leaq -0x260(%rbp), %rdi
leaq -0x110(%rbp), %rdx
leaq 0x1656df(%rip), %rsi    # 0x16f53d
movb $0x0, %al
callq 0x9060
leaq -0x260(%rbp), %rdi
callq 0x92f0
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: alarm_clock()
void alarm_clock()
{
   if(alarm_file)           play_tune(ALARM_FILE, 1);
   else if(chord_file == 2) play_tune(USER_CHORD_FILE, 1);
   else if(chord_file)      play_tune(CHORD_FILE, 0);
   else                     BEEP(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x363578(%rip)    # 0x36d4a3
je 0x9f40
leaq 0x165471(%rip), %rdi    # 0x16f3a5
movl $0x1, %esi
callq 0x9de0
jmp 0x9f86
movzbl 0x363356(%rip), %eax    # 0x36d29d
cmpl $0x2, %eax
jne 0x9f5f
leaq 0x1654e6(%rip), %rdi    # 0x16f439
movl $0x1, %esi
callq 0x9de0
jmp 0x9f84
cmpb $0x0, 0x363337(%rip)    # 0x36d29d
je 0x9f78
leaq 0x1654dc(%rip), %rdi    # 0x16f44b
xorl %esi, %esi
callq 0x9de0
jmp 0x9f82
movl $0x1, %edi
callq 0x9ec0
jmp 0x9f84
jmp 0x9f86
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: cuckoo_clock()
void cuckoo_clock()
{
char fn[MAX_PATH+1];

   if(singing_clock) {  // sing a song file
      get_alarm_time();
      if((singing_clock == 2) && (g_minutes == 0)) {  // Big Ben mode - play a different file each hour on the hour
         sprintf(fn, HOUR_NAME, g_hours%12);
      }
      else {
         sprintf(fn, SONG_NAME, g_minutes);
      }
      play_tune(fn, 1);
      cuckoo_beeps = 0;
   }
   else if(ships_clock && (ring_bell >= 0) && (bell_number >= 0) && (bell_number < MAX_BELLS)) {
      if(bell_file && (bells[ring_bell][bell_number])) play_tune(BELL_FILE, 1);
      if(++bell_number >= MAX_BELLS) bell_number = (-1);
   }
   else if(chime_file) play_tune(CHIME_FILE, 1);
   else if(notify_file == 2) play_tune(USER_NOTIFY_FILE, 1);
   else if(notify_file) play_tune(NOTIFY_FILE, 0);
   else BEEP(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
cmpb $0x0, 0x36311b(%rip)    # 0x36d0bd
je 0xa01b
callq 0x135fa0
movzbl 0x36310d(%rip), %eax    # 0x36d0bd
cmpl $0x2, %eax
jne 0x9fe3
cmpl $0x0, 0x3628d0(%rip)    # 0x36c88c
jne 0x9fe3
leaq -0x110(%rbp), %rdi
movl 0x3628bd(%rip), %eax    # 0x36c888
movl $0xc, %ecx
cltd
idivl %ecx
leaq 0x16558e(%rip), %rsi    # 0x16f568
movb $0x0, %al
callq 0x9060
jmp 0x9ffe
leaq -0x110(%rbp), %rdi
movl 0x36289c(%rip), %edx    # 0x36c88c
leaq 0x165586(%rip), %rsi    # 0x16f57d
movb $0x0, %al
callq 0x9060
leaq -0x110(%rbp), %rdi
movl $0x1, %esi
callq 0x9de0
movb $0x0, 0x3630a9(%rip)    # 0x36d0bf
jmp 0xa101
cmpb $0x0, 0x36309f(%rip)    # 0x36d0c1
je 0xa09b
cmpl $0x0, 0x363099(%rip)    # 0x36d0c4
jl 0xa09b
cmpl $0x0, 0x363094(%rip)    # 0x36d0c8
jl 0xa09b
cmpl $0xc, 0x36308b(%rip)    # 0x36d0c8
jge 0xa09b
cmpb $0x0, 0x363461(%rip)    # 0x36d4a7
je 0xa07b
movslq 0x363075(%rip), %rcx    # 0x36d0c4
leaq 0x1b3eea(%rip), %rax    # 0x1bdf40
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movslq 0x363064(%rip), %rcx    # 0x36d0c8
cmpl $0x0, (%rax,%rcx,4)
je 0xa07b
leaq 0x16537f(%rip), %rdi    # 0x16f3f0
movl $0x1, %esi
callq 0x9de0
movl 0x363047(%rip), %eax    # 0x36d0c8
addl $0x1, %eax
movl %eax, 0x36303e(%rip)    # 0x36d0c8
cmpl $0xc, %eax
jl 0xa099
movl $0xffffffff, 0x36302f(%rip) # imm = 0xFFFFFFFF
jmp 0xa0ff
cmpb $0x0, 0x3633fe(%rip)    # 0x36d4a0
je 0xa0b7
leaq 0x1652e8(%rip), %rdi    # 0x16f393
movl $0x1, %esi
callq 0x9de0
jmp 0xa0fd
movzbl 0x3631e0(%rip), %eax    # 0x36d29e
cmpl $0x2, %eax
jne 0xa0d6
leaq 0x16539c(%rip), %rdi    # 0x16f466
movl $0x1, %esi
callq 0x9de0
jmp 0xa0fb
cmpb $0x0, 0x3631c1(%rip)    # 0x36d29e
je 0xa0ef
leaq 0x165393(%rip), %rdi    # 0x16f479
xorl %esi, %esi
callq 0x9de0
jmp 0xa0f9
movl $0x2, %edi
callq 0x9ec0
jmp 0xa0fb
jmp 0xa0fd
jmp 0xa0ff
jmp 0xa101
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: trim_whitespace(char*)
char *trim_whitespace(char *p)
{
char *s;

   // return pointer to first non-whitespace char in string p
   // returns 0 for null or empty string

   if(p == 0) return 0;

   s = p;
   while(*s) {
      if(*s == ' ') ++s;
      else if(*s == '\t') ++s;
      else return s;
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa169
movq $0x0, -0x8(%rbp)
jmp 0xa1c4
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0xa1bc
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0xa194
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa1ba
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0xa1ae
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa1b8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa1c4
jmp 0xa1ba
jmp 0xa171
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: text_editor()
void text_editor()
{
char *e;

   // run a text editor program
   if(no_exec) return;

   e = getenv("HEATHER_EDITOR");
   if(!e || !*e) {
      e = getenv("EDITOR");
   }
   if(!e || !*e) {
      e = editor;
   }

   run_program(e, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x362f45(%rip)    # 0x36d294
je 0xa353
jmp 0xa3a9
leaq 0x16527b(%rip), %rdi    # 0x16f5d5
callq 0x9470
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa373
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xa383
leaq 0x165263(%rip), %rdi    # 0x16f5dd
callq 0x9470
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa393
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xa39e
movq 0x1b296e(%rip), %rax    # 0x1bcd08
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xa1d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heather.cpp
// Function: exec_program()
void exec_program()
{
char *e;

   // run a user defined program on a schedule
   if(no_exec) return;

   e = getenv("HEATHER_EXEC");
   if(!e || !*e) {
      e = heather_exec;
   }
   strcpy(edit_buffer, e);
   strcpy(out, e);

   run_program(out, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x362ed5(%rip)    # 0x36d294
je 0xa3c3
jmp 0xa41c
leaq 0x16521a(%rip), %rdi    # 0x16f5e4
callq 0x9470
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa3e3
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xa3ee
movq 0x1b2926(%rip), %rax    # 0x1bcd10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x3940c7(%rip), %rdi    # 0x39e4c0
callq 0x9350
movq -0x8(%rbp), %rsi
leaq 0x390ff7(%rip), %rdi    # 0x39b400
callq 0x9350
leaq 0x390feb(%rip), %rdi    # 0x39b400
xorl %esi, %esi
callq 0xa1d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: path_unlink(char*)
int path_unlink(char *fn)
{
char name[2048+1];
char *f;

   // delete a file, add path name if none given
   f = trim_whitespace(fn);
   if(f == 0) return 1;

   strcpy(name, f);

#ifdef WINDOWS
#else // __linux__  __MACH__  __FreeBSD__
   if(f[0] == '.') ;       // user gave a path
   else if(f[0] == '/') ;  // user gave a path
   else {  // add path to heather directory
      strcpy(name, heather_path);
      strcat(name, f);
   }
#endif

   return unlink(name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x830, %rsp            # imm = 0x830
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa150
movq %rax, -0x828(%rbp)
cmpq $0x0, -0x828(%rbp)
jne 0xa462
movl $0x1, -0x4(%rbp)
jmp 0xa4ce
leaq -0x820(%rbp), %rdi
movq -0x828(%rbp), %rsi
callq 0x9350
movq -0x828(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xa486
jmp 0xa4bf
movq -0x828(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xa497
jmp 0xa4bd
leaq -0x820(%rbp), %rdi
leaq 0x1c59cb(%rip), %rsi    # 0x1cfe70
callq 0x9350
leaq -0x820(%rbp), %rdi
movq -0x828(%rbp), %rsi
callq 0x96a0
jmp 0xa4bf
leaq -0x820(%rbp), %rdi
callq 0x9130
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x830, %rsp            # imm = 0x830
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: path_open(char*, char*)
FILE *path_open(char *fn, char *m)
{
char name[2048+1];
char *f;
FILE *fp;

   // open a file, add path name if none given
   if(m == 0) return 0;
   f = trim_whitespace(fn);
   if(f == 0) return 0;

   strcpy(name, f);

#ifdef WINDOWS
#else // __linux__  __MACH__  __FreeBSD__
   if(f[0] == '.') ;       // user gave a path
   else if(f[0] == '/') ;  // user gave a path
   else {  // add path to heather directory
      strcpy(name, heather_path);
      strcat(name, f);
   }
#endif

   fp = fopen(name, m);
   if(fp) {
      if(debug_file) fprintf(debug_file, "! file %s opened\n", name);
   }
if(show_debug_info) printf("path_open(%s, %s) -> %p\n", name, m, fp);
   return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x830, %rsp            # imm = 0x830
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa507
movq $0x0, -0x8(%rbp)
jmp 0xa608
movq -0x10(%rbp), %rdi
callq 0xa150
movq %rax, -0x828(%rbp)
cmpq $0x0, -0x828(%rbp)
jne 0xa52e
movq $0x0, -0x8(%rbp)
jmp 0xa608
leaq -0x820(%rbp), %rdi
movq -0x828(%rbp), %rsi
callq 0x9350
movq -0x828(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xa552
jmp 0xa58b
movq -0x828(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xa563
jmp 0xa589
leaq -0x820(%rbp), %rdi
leaq 0x1c58ff(%rip), %rsi    # 0x1cfe70
callq 0x9350
leaq -0x820(%rbp), %rdi
movq -0x828(%rbp), %rsi
callq 0x96a0
jmp 0xa58b
leaq -0x820(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9440
movq %rax, -0x830(%rbp)
cmpq $0x0, -0x830(%rbp)
je 0xa5d4
cmpq $0x0, 0x292fbc(%rip)    # 0x29d570
je 0xa5d2
movq 0x292fb3(%rip), %rdi    # 0x29d570
leaq -0x820(%rbp), %rdx
leaq 0x165026(%rip), %rsi    # 0x16f5f1
movb $0x0, %al
callq 0x9550
jmp 0xa5d4
cmpb $0x0, 0x26d4c9(%rip)    # 0x277aa4
je 0xa5fd
leaq -0x820(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x830(%rbp), %rcx
leaq 0x16500d(%rip), %rdi    # 0x16f603
movb $0x0, %al
callq 0x9030
movq -0x830(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x830, %rsp            # imm = 0x830
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heather.cpp
// Function: open_debug_file(char*)
FILE *open_debug_file(char *f)
{
char *s;
char *star;

   s = trim_whitespace(f);
   if(s == 0) return 0;

   if(debug_file) {
      fclose(debug_file);
      debug_file = 0;
   }

   star = strchr(s, FLUSH_CHAR);
   if(star) {
      *star = 0;
      dbg_flush_mode = 1;
   }
   else dbg_flush_mode = 0;

   debug_file = topen(s, "w");
   strcpy(debug_name, s);
   return debug_file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa150
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa64d
movq $0x0, -0x8(%rbp)
jmp 0xa6d6
cmpq $0x0, 0x292f1b(%rip)    # 0x29d570
je 0xa66e
movq 0x292f12(%rip), %rdi    # 0x29d570
callq 0x9380
movq $0x0, 0x292f02(%rip) # 0x29d570
movq -0x18(%rbp), %rdi
movl $0x2a, %esi
callq 0x9100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa69a
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movl $0x1, 0x292f70(%rip)    # 0x29d608
jmp 0xa6a4
movl $0x0, 0x292f64(%rip)    # 0x29d608
movq -0x18(%rbp), %rdi
leaq 0x179f9c(%rip), %rsi    # 0x18464b
callq 0x9b20
movq %rax, 0x292eb5(%rip)    # 0x29d570
movq -0x18(%rbp), %rsi
leaq 0x29257a(%rip), %rdi    # 0x29cc40
callq 0x9350
movq 0x292e9e(%rip), %rax    # 0x29d570
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq