LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::deleteAttributes()
void Datablock::deleteAttributes()
{
	_attribute * entry;
	while(!_list.empty())
	{
		//trace("Remove a entry.");
		entry = _list.back();
		deleteAttribute(entry);
		entry->destroy();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
addq $0x38, %rdi
callq 0x423740
xorb $-0x1, %al
testb $0x1, %al
jne 0x422aed
jmp 0x422b1d
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
addq $0x38, %rdi
callq 0x423780
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x422c10
movq -0x10(%rbp), %rdi
callq 0x422cf0
jmp 0x422ad4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::deleteAttribute(u::Datablock::_attribute*)
void Datablock::deleteAttribute(Datablock::_attribute *entry)
{
	int64 i,l;

	l=_list.size();
	for(i=0; i<l; i++)
	{
		if(_list[i] == entry)
		{
			_list.erase(i);
			break;
		}
	}

	l = entry->ref.size();
	for(i=0; i<l; i++)
	{
		if(entry->ref[i] == this)
		{
			entry->ref.erase(i);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x38, %rdi
addq $0x38, %rdi
callq 0x4236f0
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x422c85
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x423710
cmpq -0x10(%rbp), %rax
jne 0x422c75
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x423860
jmp 0x422c85
jmp 0x422c77
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x422c41
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
addq $0x38, %rdi
callq 0x4238d0
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x422ce9
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
movq -0x18(%rbp), %rsi
callq 0x4238f0
movq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jne 0x422cd9
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
movq -0x18(%rbp), %rsi
callq 0x423920
jmp 0x422ce9
jmp 0x422cdb
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x422ca2
addq $0x30, %rsp
popq %rbp
retq
nop
// File: enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::operator[](u::String)
Datablock::_attribute & Datablock::operator[](String name)
{
	int64 i,l;
	_attribute *entry;
	l = _list.size();
	for(i=0; i<l; i++)
	{
		entry = _list[i];
		if(entry->name == name) return *entry;
	}
	entry = new _attribute(name);

	saveAttribute(entry);

	return *entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
addq $0x38, %rdi
addq $0x38, %rdi
callq 0x4236f0
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x422dff
movq -0xa0(%rbp), %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rsi
callq 0x423710
movq -0xa8(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
addq $0x38, %rdi
addq $0x38, %rsi
callq 0x409490
testb $0x1, %al
jne 0x422de2
jmp 0x422def
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x422ec9
jmp 0x422df1
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x422d9e
movl $0xc0, %edi
callq 0x434cd0
movq -0xa8(%rbp), %rsi
movq %rax, -0xb0(%rbp)
movb $0x1, -0x95(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x417f20
jmp 0x422e2c
movq -0xb0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x4232b0
jmp 0x422e41
movq -0xb0(%rbp), %rax
movb $0x0, -0x95(%rbp)
movq %rax, -0x30(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x405650
movq -0xa0(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x422b30
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x422ec9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x422eab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x405650
testb $0x1, -0x95(%rbp)
jne 0x422eb6
jmp 0x422ec7
movq -0xb0(%rbp), %rdi
movl $0xc0, %esi
callq 0x433cf0
jmp 0x422ed6
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x4deb40
nopw %cs:(%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::toString()
String Datablock::toString()
{
	String str = "[" + className();
	str += " length=" + int2string(_list.size());
	str += "]";
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x120(%rbp)
movb $0x0, -0x11(%rbp)
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x90(%rbp), %rdi
callq *%rax
leaq -0x58(%rbp), %rdx
leaq 0x1b9568(%rip), %rsi    # 0x5dc4a6
leaq -0x38(%rbp), %rdi
callq 0x405d50
jmp 0x422f49
movq -0x130(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x417ce0
jmp 0x422f5b
leaq -0x38(%rbp), %rdi
callq 0x4adc60
leaq -0x90(%rbp), %rdi
callq 0x405650
movq -0x120(%rbp), %rdi
addq $0x70, %rdi
callq 0x4236f0
movl %eax, %esi
leaq -0x118(%rbp), %rdi
callq 0x4178a0
jmp 0x422f90
leaq -0xe0(%rbp), %rdx
leaq 0x1b80d0(%rip), %rsi    # 0x5db06e
leaq -0xc0(%rbp), %rdi
callq 0x405d50
jmp 0x422fac
movq -0x130(%rbp), %rdi
addq $0x38, %rdi
leaq -0xc0(%rbp), %rsi
callq 0x4af380
jmp 0x422fc5
leaq -0xc0(%rbp), %rdi
callq 0x4adc60
leaq -0x118(%rbp), %rdi
callq 0x405650
movq -0x130(%rbp), %rdi
addq $0x38, %rdi
leaq 0x1dd997(%rip), %rsi    # 0x600986
callq 0x4af460
jmp 0x422ff6
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4230a6
jmp 0x42309a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x423038
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4adc60
leaq -0x90(%rbp), %rdi
callq 0x405650
jmp 0x4230c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x4230b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x42308c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x4adc60
leaq -0x118(%rbp), %rdi
callq 0x405650
jmp 0x4230b6
movq -0x130(%rbp), %rdi
callq 0x405650
movq -0x128(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x130(%rbp), %rdi
callq 0x405650
movq -0x98(%rbp), %rdi
callq 0x4deb40
nop
// File: enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::_attribute::operator=(u::Object*)
Object *Datablock::_attribute::operator =(Object *value)
{
	destroyValue();
	isObject = true;
	this->value = value;
	//trace("Save as Object.");
	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x423190
movq -0x18(%rbp), %rax
movb $0x1, 0x68(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::_attribute::destroyValue()
void Datablock::_attribute::destroyValue()
{
	if(value != null)
	{
		if(isObject == true)
		{
			//trace("Destroy object.");
			if(valid((Object *)value)) ((Object*)value)->destroy();
		}
		else
		{
			//trace("Destroy a int.");
			delete (int64*)value;
		}
		value = null;
		if(_noDelete == false) delete (_attribute*)this;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x60(%rax)
je 0x423241
movq -0x10(%rbp), %rax
movb 0x68(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4231e2
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x418ae0
testb $0x1, %al
jne 0x4231d3
jmp 0x4231e0
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
jmp 0x423204
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x423202
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x433cf0
jmp 0x423204
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x42323f
movq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x42323d
movq -0x10(%rbp), %rdi
callq 0x423350
movq -0x10(%rbp), %rdi
movl $0xc0, %esi
callq 0x433cf0
jmp 0x42323f
jmp 0x423241
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::_attribute::operator=(long)
int64 Datablock::_attribute::operator =(int64 value)
{
	destroyValue();
	isObject = false;
	this->value = new int64();
	*((int64*)this->value) = value;

	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x423190
movq -0x18(%rbp), %rax
movb $0x0, 0x68(%rax)
movl $0x8, %edi
callq 0x434cd0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq $0x0, (%rcx)
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rcx
movq 0x60(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::_attribute::_attribute(u::String)
u::Datablock::_attribute::_attribute(String keyName)
{
	_noDelete = false;
	value = null;
	isObject = false;
	name = keyName;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x417c00
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x28(%rbp)
callq 0x4239d0
jmp 0x4232ec
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdi
movb $0x0, (%rdi)
movq $0x0, 0x60(%rdi)
movb $0x0, 0x68(%rdi)
addq $0x8, %rdi
callq 0x4180d0
jmp 0x42330e
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x423337
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x423a40
movq -0x38(%rbp), %rdi
callq 0x405650
movq -0x18(%rbp), %rdi
callq 0x4deb40
nopl (%rax)
// File: enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::hasKey(u::String)
bool u::Datablock::hasKey(String key)
{
	int64 l = _list.length(), i;
	for(i = 0; i < l; i++)
	{
		if(_list[i]->name == key) return true;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x38, %rdi
callq 0x423a70
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x423450
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movq -0x28(%rbp), %rsi
callq 0x423710
movq -0x38(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
addq $0x38, %rdi
addq $0x38, %rsi
callq 0x409490
testb $0x1, %al
jne 0x42343a
jmp 0x423440
movb $0x1, -0x1(%rbp)
jmp 0x423454
jmp 0x423442
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x423401
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::getKeys()
Vector<String> u::Datablock::getKeys()
{
	Vector<String> result;
	int length = _list.length(), i;
	for(i = 0; i < length; i++)
	{
		result.push(_list[i]->name);
	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x4055b0
movq -0x90(%rbp), %rdi
addq $0x38, %rdi
callq 0x423a70
movq %rax, -0x88(%rbp)
jmp 0x4234b1
movq -0x88(%rbp), %rax
movl %eax, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x423548
movq -0x90(%rbp), %rdi
addq $0x38, %rdi
movslq -0x28(%rbp), %rsi
callq 0x423710
movq %rax, -0xa8(%rbp)
jmp 0x4234e7
movq -0xa8(%rbp), %rsi
addq $0x8, %rsi
leaq -0x80(%rbp), %rdi
callq 0x417f20
jmp 0x4234fd
movq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x40b430
jmp 0x42350f
leaq -0x80(%rbp), %rdi
callq 0x405650
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4234c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x42356e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x405650
jmp 0x42356e
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x42355e
movq -0xa0(%rbp), %rdi
callq 0x405700
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x405700
movq -0x20(%rbp), %rdi
callq 0x4deb40
nopw %cs:(%rax,%rax)
// File: enbock[P]Warp10Server/ulib/src/Datablock.cpp
// Function: u::Datablock::remove(u::String)
void u::Datablock::remove(String key)
{
	int64 l = _list.length(), i;
	for(i = 0; i < l; i++)
	{
		if(_list[i]->name == key) {
			delete (_attribute*)_list[i];
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x38, %rdi
callq 0x423a70
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x42363e
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rsi
callq 0x423710
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
addq $0x38, %rdi
addq $0x38, %rsi
callq 0x409490
testb $0x1, %al
jne 0x4235fa
jmp 0x42362e
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rsi
callq 0x423710
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x42362c
movq -0x38(%rbp), %rdi
callq 0x423350
movq -0x38(%rbp), %rdi
movl $0xc0, %esi
callq 0x433cf0
jmp 0x42363e
jmp 0x423630
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4235c1
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: supervoltage[P]morsetran/source/mttmode.cpp
// Function: morseToTextMode(int, char**)
void morseToTextMode(int argc, char **argv)
{
	string morseIn;
	
	for(int i = 1; i < argc; i++)
	{
		morseIn = argv[i];
		cout << getLetter(morseIn);
	}
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2190
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2afc
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2180
jmp 0x2a92
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2070
jmp 0x2aa1
leaq -0x68(%rbp), %rdi
callq 0x2b40
movb %al, -0x69(%rbp)
jmp 0x2aaf
movb -0x69(%rbp), %al
movsbl %al, %esi
movq 0x451c(%rip), %rdi      # 0x6fd8
callq 0x2160
jmp 0x2ac3
leaq -0x68(%rbp), %rdi
callq 0x2090
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2a6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2090
jmp 0x2b20
movq 0x44d5(%rip), %rdi      # 0x6fd8
movq 0x44be(%rip), %rsi      # 0x6fc8
callq 0x2110
jmp 0x2b11
leaq -0x30(%rbp), %rdi
callq 0x2090
addq $0x70, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x2090
movq -0x40(%rbp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: supervoltage[P]morsetran/source/ttmmode.cpp
// Function: textToMorseMode(int, char**)
void textToMorseMode(int argc, char **argv)
{
	string textIn;
	
	for(int i = 1; i < argc; i++)
	{
		string textIn = argv[i];
		
		for(int j = 0; j < textIn.length(); j++)
		{
			cout << getMorse(textIn[j]) << " ";
		}
		
		if(i == argc - 1)
			break;
		else
			cout << " / ";
	}
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2190
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x33c8
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0xa8(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x21f0
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x26d0
jmp 0x326a
leaq -0x59(%rbp), %rdi
callq 0x2130
movl $0x0, -0x70(%rbp)
movslq -0x70(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x21b0
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0x335c
movslq -0x70(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x2220
movq %rax, -0xb8(%rbp)
jmp 0x32b7
movq -0xb8(%rbp), %rax
movsbl (%rax), %esi
leaq -0x90(%rbp), %rdi
callq 0x3410
jmp 0x32cf
movq 0x3d02(%rip), %rdi      # 0x6fd8
leaq -0x90(%rbp), %rsi
callq 0x20f0
movq %rax, -0xc0(%rbp)
jmp 0x32eb
movq -0xc0(%rbp), %rdi
leaq 0x1d45(%rip), %rsi      # 0x503e
callq 0x2100
jmp 0x3300
leaq -0x90(%rbp), %rdi
callq 0x2090
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x327a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x2130
jmp 0x33fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x33bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2090
jmp 0x33bd
movl -0x34(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x3375
movl $0x2, -0x94(%rbp)
jmp 0x3396
movq 0x3c5c(%rip), %rdi      # 0x6fd8
leaq 0x1e6f(%rip), %rsi      # 0x51f2
callq 0x2100
jmp 0x338a
jmp 0x338c
movl $0x0, -0x94(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2090
movl -0x94(%rbp), %eax
testl %eax, %eax
je 0x33ad
jmp 0x33ab
jmp 0x33c8
jmp 0x33af
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3222
leaq -0x58(%rbp), %rdi
callq 0x2090
jmp 0x33fb
movq 0x3c09(%rip), %rdi      # 0x6fd8
movq 0x3bf2(%rip), %rsi      # 0x6fc8
callq 0x2110
jmp 0x33dd
leaq -0x30(%rbp), %rdi
callq 0x2090
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2090
movq -0x68(%rbp), %rdi
callq 0x21e0
nopl (%rax)
// File: demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::invalid_syntax::get_template[abi:cxx11](boost::program_options::invalid_syntax::kind_t)
string 
    invalid_syntax::get_template(kind_t kind)
    {
        // Initially, store the message in 'const char*' variable,
        // to avoid conversion to string in all cases.
        const char* msg;
        switch(kind)
        {
        case empty_adjacent_parameter:
            msg = "the argument for option '%canonical_option%' should follow immediately after the equal sign";
            break;
        case missing_parameter:
            msg = "the required argument for option '%canonical_option%' is missing";
            break;
        case unrecognized_line:
            msg = "the options configuration file contains an invalid line '%invalid_line%'";
            break;
        // none of the following are currently used:
        case long_not_allowed:
            msg = "the unabbreviated option '%canonical_option%' is not valid";
            break;
        case long_adjacent_not_allowed:
            msg = "the unabbreviated option '%canonical_option%' does not take any arguments";
            break;
        case short_adjacent_not_allowed:
            msg = "the abbreviated option '%canonical_option%' does not take any arguments";
            break;
        case extra_parameter:
            msg = "option '%canonical_option%' does not take any arguments";
            break;
        default:
            msg = "unknown command line syntax error for '%s'";
        }
        return msg;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1e, %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x6, %eax
ja 0xe70e
movq -0x40(%rbp), %rax
leaq 0x5095a(%rip), %rcx     # 0x5f004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x50967(%rip), %rax     # 0x5f021
movq %rax, -0x20(%rbp)
jmp 0xe719
leaq 0x509b6(%rip), %rax     # 0x5f07d
movq %rax, -0x20(%rbp)
jmp 0xe719
leaq 0x509ea(%rip), %rax     # 0x5f0be
movq %rax, -0x20(%rbp)
jmp 0xe719
leaq 0x50a26(%rip), %rax     # 0x5f107
movq %rax, -0x20(%rbp)
jmp 0xe719
leaq 0x50a54(%rip), %rax     # 0x5f142
movq %rax, -0x20(%rbp)
jmp 0xe719
leaq 0x50a91(%rip), %rax     # 0x5f18c
movq %rax, -0x20(%rbp)
jmp 0xe719
leaq 0x50a94(%rip), %rax     # 0x5f19c
movq %rax, -0x20(%rbp)
jmp 0xe719
leaq 0x50abf(%rip), %rax     # 0x5f1d4
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x21(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xdb50
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0xd8b0
jmp 0xe741
leaq -0x21(%rbp), %rdi
callq 0xd6b0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0xd6b0
movq -0x30(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::init(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void
    cmdline::init(const vector<string>& args)
    {
        this->args = args;        
        m_style = command_line_style::default_style;
        m_desc = 0;
        m_positional = 0;
        m_allow_unregistered = false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x11ed0
movq -0x18(%rbp), %rax
movl $0x3f7, 0x18(%rax)      # imm = 0x3F7
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movb $0x0, 0x1c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::cmdline(int, char const* const*)
cmdline::cmdline(int argc, const char*const * argv)
    {
#if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
        vector<string> args;
        copy(argv+1, argv+argc+!argc, inserter(args, args.end()));
        init(args);
#else
        init(vector<string>(argv+1, argv+argc+!argc));
#endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x11cf0
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x50(%rbp)
callq 0x11d10
jmp 0xe8bd
movq -0x60(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x68(%rbp)
callq 0x11d30
jmp 0xe8d0
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x80(%rbp)
movslq -0xc(%rbp), %rdx
testq %rdx, %rdx
sete %cl
leaq (%rax,%rdx,8), %rax
movzbl %cl, %ecx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x11e10
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x70(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0x11e30
jmp 0xe91c
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xe830
jmp 0xe92b
leaq -0x40(%rbp), %rdi
callq 0x11db0
leaq -0x41(%rbp), %rdi
callq 0x11eb0
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xe9a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xe997
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xe985
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x11db0
leaq -0x41(%rbp), %rdi
callq 0x11eb0
movq -0x68(%rbp), %rdi
callq 0x11d50
movq -0x50(%rbp), %rdi
callq 0x11d80
movq -0x58(%rbp), %rdi
callq 0x11db0
movq -0x20(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
// File: demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::style(int)
void 
    cmdline::style(int style)
    {
        if (style == 0) 
            style = default_style;        

        check_style(style);
        this->m_style = style_t(style);
    }

// 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)
cmpl $0x0, -0xc(%rbp)
jne 0xe9e4
movl $0x3f7, -0xc(%rbp)      # imm = 0x3F7
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xea00
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::get_canonical_option_prefix()
int
    cmdline::get_canonical_option_prefix()
    {
        if (m_style & allow_long)
            return allow_long;

        if (m_style & allow_long_disguise)
            return allow_long_disguise;

        if ((m_style & allow_short) && (m_style & allow_dash_for_short))
            return allow_dash_for_short;

        if ((m_style & allow_short) && (m_style & allow_slash_for_short))
            return allow_slash_for_short;

        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xec24
movl $0x1, -0x4(%rbp)
jmp 0xec93
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0xec3e
movl $0x1000, -0x4(%rbp)     # imm = 0x1000
jmp 0xec93
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xec65
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xec65
movl $0x4, -0x4(%rbp)
jmp 0xec93
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xec8c
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xec8c
movl $0x8, -0x4(%rbp)
jmp 0xec93
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::handle_additional_parser(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
vector<option> 
    cmdline::handle_additional_parser(vector<string>& args)
    {
        vector<option> result;
        pair<string, string> r = m_additional_parser(args[0]);
        if (!r.first.empty()) {
            option next;
            next.string_key = r.first;
            if (!r.second.empty())
                next.value.push_back(r.second);
            result.push_back(next);
            args.erase(args.begin());
        }
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x108(%rbp)
movq %rdi, %rax
movq %rax, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf8(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x12450
movq -0xf8(%rbp), %rax
addq $0x30, %rax
movq %rax, -0xf0(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12820
movq -0xf0(%rbp), %rsi
movq %rax, %rdx
leaq -0x60(%rbp), %rdi
callq 0x13170
jmp 0xfee0
leaq -0x60(%rbp), %rdi
callq 0xdab0
testb $0x1, %al
jne 0xffea
leaq -0xd0(%rbp), %rdi
callq 0x12760
jmp 0xfeff
leaq -0xd0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xd060
jmp 0xff11
leaq -0x60(%rbp), %rdi
addq $0x20, %rdi
callq 0xdab0
testb $0x1, %al
jne 0xff75
leaq -0xa8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x127b0
jmp 0xff34
jmp 0xff75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x10026
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xffff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x12920
jmp 0xffff
movq -0x108(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x12690
jmp 0xff8a
movq -0x18(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x128b0
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x128e0
movq -0x118(%rbp), %rdi
movq -0xd8(%rbp), %rsi
callq 0x12840
movq %rax, -0x110(%rbp)
jmp 0xffd0
movq -0x110(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x12920
movb $0x1, -0x19(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x13220
testb $0x1, -0x19(%rbp)
jne 0x10016
jmp 0x1000a
leaq -0x60(%rbp), %rdi
callq 0x13220
jmp 0x10026
movq -0x108(%rbp), %rdi
callq 0x12700
movq -0x100(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x108(%rbp), %rdi
callq 0x12700
movq -0x68(%rbp), %rdi
callq 0xdb30
nopl (%rax,%rax)
// File: demon386[P]git-store/./libs/program_options/src/cmdline.cpp
// Function: boost::program_options::detail::cmdline::parse_terminator(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
vector<option> 
    cmdline::parse_terminator(vector<string>& args)
    {
        vector<option> result;
        const string& tok = args[0];
        if (tok == "--")
        {
            for(unsigned i = 1; i < args.size(); ++i)
            {
                option opt;
                opt.value.push_back(args[i]);
                opt.original_tokens.push_back(args[i]);
                opt.position_key = INT_MAX;
                result.push_back(opt);
            }
            args.clear();
        }
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x12450
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12820
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x4f3bb(%rip), %rsi     # 0x60378
callq 0x13120
movb %al, -0x99(%rbp)
jmp 0x10fca
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x10fd9
jmp 0x110cf
movl $0x1, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x124d0
movq %rax, %rcx
movq -0xb8(%rbp), %rax
cmpq %rcx, %rax
jae 0x110c6
leaq -0x98(%rbp), %rdi
callq 0x12760
jmp 0x11014
leaq -0x70(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rdi
movl -0x38(%rbp), %eax
movl %eax, %esi
callq 0x12820
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
callq 0x127b0
jmp 0x1103e
leaq -0x58(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x18(%rbp), %rdi
movl -0x38(%rbp), %eax
movl %eax, %esi
callq 0x12820
movq -0xc8(%rbp), %rdi
movq %rax, %rsi
callq 0x127b0
jmp 0x11068
movq -0xb0(%rbp), %rdi
movl $0x7fffffff, -0x78(%rbp) # imm = 0x7FFFFFFF
leaq -0x98(%rbp), %rsi
callq 0x12690
jmp 0x11084
leaq -0x98(%rbp), %rdi
callq 0x12920
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x10fe0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x110f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x12920
jmp 0x110f5
movq -0x18(%rbp), %rdi
callq 0x13150
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x110e5
movq -0xb0(%rbp), %rdi
callq 0x12700
movq -0xa8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x12700
movq -0x30(%rbp), %rdi
callq 0xdb30
nopw (%rax,%rax)
// File: demon386[P]git-store/./boost/throw_exception.hpp
// Function: void boost::throw_exception<boost::program_options::invalid_command_line_style>(boost::program_options::invalid_command_line_style const&)
BOOST_NORETURN inline void throw_exception( E const & e )
{
    //All boost exceptions are required to derive from std::exception,
    //to ensure compatibility with BOOST_NO_EXCEPTIONS.
    throw_exception_assert_compatibility(e);

#ifndef BOOST_EXCEPTION_DISABLE
    throw enable_current_exception(enable_error_info(e));
#else
    throw e;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x167f0
movb $0x1, -0x4d(%rbp)
movl $0x40, %edi
callq 0xd2b0
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x16830
jmp 0x12156
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x16800
jmp 0x12165
movq -0x58(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
leaq 0x78c4c(%rip), %rsi     # 0x8adc0
leaq 0x46e5(%rip), %rdx      # 0x16860
callq 0xdad0
jmp 0x121c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x121a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x168a0
testb $0x1, -0x4d(%rbp)
jne 0x121ad
jmp 0x121b6
movq -0x58(%rbp), %rdi
callq 0xd460
jmp 0x121b8
movq -0x48(%rbp), %rdi
callq 0xdb30
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: demon386[P]git-store/./boost/function/function_template.hpp
// Function: boost::function1<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
result_type operator()(BOOST_FUNCTION_PARMS) const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

      return get_vtable()->invoker
               (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x78(%rbp)
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x174d0
testb $0x1, %al
jne 0x2fd69
jmp 0x2fd9b
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x18df0
movq -0x80(%rbp), %rdi
callq 0x18d40
jmp 0x2fd81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x18e30
jmp 0x2fe25
movq -0x60(%rbp), %rdi
callq 0x34550
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq 0x8(%rcx), %rcx
movq %rcx, -0x88(%rbp)
addq $0x8, %rax
movq %rax, -0x98(%rbp)
callq 0x34570
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xd350
movq -0x70(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq -0x88(%rbp), %rax
callq *%rax
jmp 0x2fdfa
leaq -0x58(%rbp), %rdi
callq 0xdca8
movq -0x68(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xdca8
movq -0x30(%rbp), %rdi
callq 0xdb30
nop
// File: demon386[P]git-store/./boost/function/function_template.hpp
// Function: boost::function1<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::operator=(boost::function1<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&> const&)
BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      BOOST_TRY {
        this->assign_to_own(f);
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x13278
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x132d6
movq -0x30(%rbp), %rdi
callq 0x15600
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d970
jmp 0x13290
jmp 0x132ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd200
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
callq 0xd990
jmp 0x132f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xda90
jmp 0x132cc
jmp 0x132e0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xdb30
movq %rax, %rdi
callq 0x129b0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: demon386[P]git-store/./boost/function/function_template.hpp
// Function: boost::function1<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::clear()
void clear()
    {
      if (vtable) {
        if (!this->has_trivial_copy_and_destroy())
          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x1564b
movq -0x10(%rbp), %rdi
callq 0x15660
testb $0x1, %al
jne 0x15640
movq -0x10(%rbp), %rdi
callq 0x15680
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x156a0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: demon386[P]git-store/./boost/function/function_template.hpp
// Function: boost::function1<std::vector<boost::program_options::basic_option<char>, std::allocator<boost::program_options::basic_option<char>>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&>::assign_to_own(boost::function1<std::vector<boost::program_options::basic_option<char>, std::allocator<boost::program_options::basic_option<char>>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&> const&)
void assign_to_own(const BOOST_FUNCTION_FUNCTION& f)
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
        if (this->has_trivial_copy_and_destroy())
          this->functor = f.functor;
        else
          get_vtable()->base.manager(f.functor, this->functor,
                                     boost::detail::function::clone_functor_tag);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x174d0
testb $0x1, %al
jne 0x178e2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
callq 0x15660
testb $0x1, %al
jne 0x1789e
jmp 0x178c0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
jmp 0x178e0
movq -0x18(%rbp), %rdi
callq 0x15740
movq -0x18(%rbp), %rsi
movq (%rax), %rax
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rsi
xorl %edx, %edx
callq *%rax
jmp 0x178e2
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: demon386[P]git-store/./boost/function/function_template.hpp
// Function: void boost::function1<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::assign_to<boost::program_options::detail::prefix_name_mapper>(boost::program_options::detail::prefix_name_mapper)
void assign_to(Functor f)
    {
      using boost::detail::function::vtable_base;

      typedef typename boost::detail::function::get_function_tag<Functor>::type tag;
      typedef boost::detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
      typedef typename get_invoker::
                         template apply<Functor, R BOOST_FUNCTION_COMMA 
                        BOOST_FUNCTION_TEMPLATE_ARGS>
        handler_type;
      
      typedef typename handler_type::invoker_type invoker_type;
      typedef typename handler_type::manager_type manager_type;

      // Note: it is extremely important that this initialization use
      // static initialization. Otherwise, we will have a race
      // condition here in multi-threaded code. See
      // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
      static const vtable_type stored_vtable = 
        { { &manager_type::manage }, &invoker_type::invoke };

      if (stored_vtable.assign_to(f, functor)) {
        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
        // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
        if (boost::has_trivial_copy_constructor<Functor>::value &&
            boost::has_trivial_destructor<Functor>::value &&
            boost::detail::function::function_allows_small_object_optimization<Functor>::value)
          value |= static_cast<std::size_t>(0x01);
        vtable = reinterpret_cast<boost::detail::function::vtable_base *>(value);
      } else 
        vtable = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x34620
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rsi
addq $0x8, %rdx
leaq 0x57be8(%rip), %rdi     # 0x8c1a0
callq 0x34710
movb %al, -0x49(%rbp)
jmp 0x345c2
leaq -0x30(%rbp), %rdi
callq 0x2ff90
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x345d4
jmp 0x34603
movq -0x60(%rbp), %rax
leaq 0x57bc1(%rip), %rcx     # 0x8c1a0
movq %rcx, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x3460e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2ff90
jmp 0x34614
movq -0x60(%rbp), %rax
movq $0x0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xdb30
nopl (%rax)
// File: demon386[P]git-store/./boost/function/function_base.hpp
// Function: boost::detail::function::functor_manager<boost::_bi::bind_t<std::vector<boost::program_options::basic_option<char>, std::allocator<boost::program_options::basic_option<char>>>, boost::_mfi::mf1<std::vector<boost::program_options::basic_option<char>, std::allocator<boost::program_options::basic_option<char>>>, boost::program_options::detail::cmdline, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&>, boost::_bi::list2<boost::_bi::value<boost::program_options::detail::cmdline*>, boost::arg<1>>>>::manage(boost::detail::function::function_buffer const&, boost::detail::function::function_buffer&, boost::detail::function::functor_manager_operation_type)
static inline void
        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
               functor_manager_operation_type op)
        {
          typedef typename get_function_tag<functor_type>::type tag_type;
          switch (op) {
          case get_functor_type_tag:
            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
            out_buffer.type.const_qualified = false;
            out_buffer.type.volatile_qualified = false;
            return;

          default:
            manager(in_buffer, out_buffer, op, tag_type());
            return;
          }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0x4, %eax
jne 0x1851d
jmp 0x184fd
movq -0x10(%rbp), %rax
leaq 0x72a50(%rip), %rcx     # 0x8af58
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x9(%rax)
jmp 0x1852d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x18600
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: demon386[P]git-store/./boost/function/function_template.hpp
// Function: bool boost::detail::function::basic_vtable1<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::assign_to<boost::program_options::detail::prefix_name_mapper>(boost::program_options::detail::prefix_name_mapper, boost::detail::function::function_buffer&, boost::detail::function::function_obj_tag) const
bool 
        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor, 
                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
            return true;
          } else {
            return false;
          }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, -0x48(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x98(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x30(%rbp), %rax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movb $0x0, %al
callq 0x18ad0
testb $0x1, %al
jne 0x34aee
movq -0xa0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x34620
movq -0x98(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x34b10
jmp 0x34ac2
leaq -0x78(%rbp), %rdi
callq 0x2ff90
movb $0x1, -0x39(%rbp)
jmp 0x34af2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x2ff90
jmp 0x34b00
movb $0x0, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0xdb30
nopl (%rax)
// File: demon386[P]git-store/./libs/program_options/src/config_file.cpp
// Function: boost::program_options::detail::common_config_file_iterator::common_config_file_iterator(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, bool)
common_config_file_iterator::common_config_file_iterator(
        const std::set<std::string>& allowed_options,
        bool allow_unregistered)
    : allowed_options(allowed_options),
      m_allow_unregistered(allow_unregistered)
    {
        for(std::set<std::string>::const_iterator i = allowed_options.begin();
            i != allowed_options.end(); 
            ++i)
        {
            add_option(i->c_str());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x1e6c0
movq -0x48(%rbp), %rdi
leaq 0x6db95(%rip), %rax     # 0x8b5c8
movq %rax, (%rdi)
addq $0x70, %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1e6f0
jmp 0x1da49
movq -0x48(%rbp), %rdi
addq $0xa0, %rdi
movq %rdi, -0x58(%rbp)
callq 0x1e720
movq -0x48(%rbp), %rdi
addq $0xd0, %rdi
movq %rdi, -0x50(%rbp)
callq 0xd8f0
movq -0x48(%rbp), %rax
movb -0x11(%rbp), %cl
andb $0x1, %cl
movb %cl, 0xf0(%rax)
movq -0x10(%rbp), %rdi
callq 0x1e740
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e7a0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1e770
testb $0x1, %al
jne 0x1daae
jmp 0x1db11
leaq -0x30(%rbp), %rdi
callq 0x1e7d0
movq %rax, %rdi
callq 0xd210
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x1db30
jmp 0x1dacd
jmp 0x1dacf
leaq -0x30(%rbp), %rdi
callq 0x1e800
jmp 0x1da8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1db17
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xdca8
movq -0x58(%rbp), %rdi
callq 0x1e830
movq -0x40(%rbp), %rdi
callq 0x1e830
jmp 0x1db17
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x1e850
movq -0x20(%rbp), %rdi
callq 0xdb30
nopl (%rax)