LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinystr.cpp
// Function: TiXmlString::assign(char const*, unsigned long)
TiXmlString& TiXmlString::assign(const char* str, size_type len)
{
	size_type cap = capacity();
	if (len > cap || cap > 3*(len + 8))
	{
		TiXmlString tmp;
		tmp.init(len);
		memcpy(tmp.start(), str, len);
		swap(tmp);
	}
	else
	{
		memmove(start(), str, len);
		set_size(len);
	}
	return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rdi), %rax
cmpq %rdx, %rax
jb 0x7831
leaq (%r14,%r14,2), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
jbe 0x7874
leaq 0x7a20(%rip), %rax      # 0xf258
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r14, %rsi
callq 0x5cf4
leaq 0x8(%rsp), %r12
movq (%r12), %r13
leaq 0x10(%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3100
movq (%rbx), %rax
movq %r13, (%rbx)
movq %rax, (%r12)
movq %r12, %rdi
callq 0x5cd8
jmp 0x788f
addq $0x10, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3260
movq (%rbx), %rax
movq %r14, (%rax)
movb $0x0, 0x10(%rax,%r14)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5cd8
movq %rbx, %rdi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinystr.cpp
// Function: TiXmlString::append(char const*, unsigned long)
TiXmlString& TiXmlString::append(const char* str, size_type len)
{
	size_type newsize = length() + len;
	if (newsize > capacity())
	{
		reserve (newsize + capacity());
	}
	memmove(finish(), str, len);
	set_size(newsize);
	return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rsi
leaq (%rcx,%rdx), %r12
cmpq %rsi, %r12
jbe 0x78eb
addq %r12, %rsi
movq %rbx, %rdi
callq 0x7788
movq (%rbx), %rax
movq (%rax), %rcx
leaq (%rax,%rcx), %rdi
addq $0x10, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3260
movq (%rbx), %rax
movq %r12, (%rax)
movb $0x0, 0x10(%rax,%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinystr.cpp
// Function: operator+(TiXmlString const&, TiXmlString const&)
TiXmlString operator + (const TiXmlString & a, const TiXmlString & b)
{
	TiXmlString tmp;
	tmp.reserve(a.length() + b.length());
	tmp += a;
	tmp += b;
	return tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x792a(%rip), %rax      # 0xf258
movq %rax, (%rdi)
movq (%rsi), %rax
movq (%rdx), %rcx
movq (%rcx), %rsi
addq (%rax), %rsi
callq 0x7788
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5a30
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a30
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5cd8
movq %r14, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinystr.cpp
// Function: operator+(TiXmlString const&, char const*)
TiXmlString operator + (const TiXmlString & a, const char* b)
{
	TiXmlString tmp;
	TiXmlString::size_type b_len = static_cast<TiXmlString::size_type>( strlen(b) );
	tmp.reserve(a.length() + b_len);
	tmp += a;
	tmp.append(b, b_len);
	return tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x78cc(%rip), %rax      # 0xf258
movq %rax, (%rdi)
movq %rdx, %rdi
callq 0x30a0
movq %rax, %r15
movq (%r12), %rax
movq (%rax), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x7788
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5a30
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x78b6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5cd8
movq %r14, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinystr.cpp
// Function: operator+(char const*, TiXmlString const&)
TiXmlString operator + (const char* a, const TiXmlString & b)
{
	TiXmlString tmp;
	TiXmlString::size_type a_len = static_cast<TiXmlString::size_type>( strlen(a) );
	tmp.reserve(a_len + b.length());
	tmp.append(a, a_len);
	tmp += b;
	return tmp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7859(%rip), %rax      # 0xf258
movq %rax, (%rdi)
movq %rsi, %rdi
callq 0x30a0
movq %rax, %r12
movq (%r14), %rax
movq (%rax), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x7788
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x78b6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a30
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5cd8
movq %r14, %rdi
callq 0x3280
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: strtrim(char*)
char* strtrim(char* str) {
    if (!str) return str;

    int len = strlen(str);
    int loff = 0, roff = len-1;
    
    /* Left offset */
    while (loff<len && str[loff]==' ') loff++;
    loff = MIN(loff, roff);

    /* Right offset*/
    while (roff>=0 && str[roff]==' ') roff--;
    roff = MAX(roff, loff);

    len = roff-loff+1;
    strncpy(str, str+loff, roff-loff+1);
    str[len] = '\0';
    return str;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x7ace
movq %rbx, %rdi
callq 0x30a0
leal -0x1(%rax), %ecx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x7a8c
cmpb $0x20, (%rbx,%rdx)
jne 0x7a8a
incq %rdx
jmp 0x7a7a
movl %edx, %eax
cmpl %ecx, %eax
cmovgel %ecx, %eax
cmpl $-0x1, %ecx
pushq $-0x1
popq %rdx
cmovll %ecx, %edx
testl %ecx, %ecx
js 0x7aac
movl %ecx, %esi
cmpb $0x20, (%rbx,%rsi)
jne 0x7aaa
decl %ecx
jmp 0x7a9a
movl %ecx, %edx
cmpl %eax, %edx
cmovlel %eax, %edx
subl %eax, %edx
incl %edx
movslq %eax, %rsi
addq %rbx, %rsi
movslq %edx, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x30c0
movb $0x0, (%rbx,%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: TiHtmlResult::~TiHtmlResult()
TiHtmlResult::~TiHtmlResult() {
    if (elements) {

        while (count > 0)  delete(elements[--count]);

        free(elements);
        elements = NULL;
        capacity = 0;
        count = 0;
    }
}

// Assembly:
leaq 0x725d(%rip), %rax      # 0xed70
movq %rax, (%rdi)
cmpq $0x0, 0x8(%rdi)
je 0x7b5c
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
pushq $0x8
popq %r14
movl 0x14(%rbx), %eax
movq 0x8(%rbx), %rdi
testl %eax, %eax
jle 0x7b4b
decl %eax
movl %eax, 0x14(%rbx)
movq (%rdi,%rax,8), %rdi
movq %r14, %rsi
callq 0x3140
jmp 0x7b2d
callq 0x31a0
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: TiHtmlResult::Append(TiHtmlElement*)
bool TiHtmlResult::Append( TiHtmlElement* element ) {
    if (capacity <= 0 || !element) return false;

    if (count >= capacity) {
        elements = (TiHtmlElement** )realloc(elements, capacity*2*sizeof(TiHtmlElement* ));
        if (elements) capacity = capacity*2;
    }
    
    elements[count++] = element;
    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x10(%rdi), %esi
testl %esi, %esi
setg %al
testq %rbx, %rbx
setne %bpl
andb %al, %bpl
cmpb $0x1, %bpl
jne 0x7bc2
movq %rdi, %r14
movq 0x8(%rdi), %rax
cmpl %esi, 0x14(%rdi)
jl 0x7bb3
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x3270
movq %rax, 0x8(%r14)
shll 0x10(%r14)
movslq 0x14(%r14), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x14(%r14)
movq %rbx, (%rax,%rcx,8)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: TiHtmlResult::Append(TiHtmlResult*)
bool TiHtmlResult::Append( TiHtmlResult* result ) {
    int count = result->Count();
    int i = 0;
    while (i < count) {
        Append(result->Element(i++));
    }
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x14(%rsi), %r15d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0x7c0d
movslq 0x14(%rbx), %rax
cmpq %rax, %r12
jge 0x7bfe
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rsi
jmp 0x7c00
xorl %esi, %esi
movq %r14, %rdi
callq 0x7b74
incq %r12
jmp 0x7be6
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: TiHtmlResult::Clear()
void TiHtmlResult::Clear() {
    if (elements) {
        while (count > 0) delete(elements[--count]);

        memset(elements, 0, sizeof(TiHtmlElement* )*capacity);
        count = 0;
    }
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x7c80
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x8
popq %r14
movl 0x14(%rbx), %eax
movq 0x8(%rbx), %rdi
testl %eax, %eax
jle 0x7c66
decl %eax
movl %eax, 0x14(%rbx)
movq (%rdi,%rax,8), %rdi
movq %r14, %rsi
callq 0x3140
jmp 0x7c48
movslq 0x10(%rbx), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x30d0
andl $0x0, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: FindByTag(TiHtmlElement*, char const*, bool)
TiHtmlResult* FindByTag( TiHtmlElement* htmlElement, const char* name,  bool deep ) {
    TiXmlElement* element = (TiXmlElement* )htmlElement->internal;
    TiXmlElement* node = NULL;
    TiHtmlResult* result = new TiHtmlResult();

    int arrayCount = 0;
    int arrayCapacity = 0;
    TiXmlElement** array = (TiXmlElement** )calloc(sizeof(TiXmlElement* ), MIN_CAPACITY);
    if (array) arrayCapacity = MIN_CAPACITY;
    int i = 0;

    /* 广度优先遍历 */
    array[i] = element;
    do {
        element = array[i];
        TIXML_FOR_EACH(element, node, name) {
            result->Append(new TiHtmlElement(node));

            //add to array
            if (deep && array) {
                if (arrayCount >= arrayCapacity) {
                    array = (TiXmlElement** )realloc(array, sizeof(TiXmlElement* )*arrayCapacity*2);
                    if (array) arrayCapacity *= 2;
                }

                if (array) {
                    array[arrayCount++] = node;
                }
            }
        }

        i++;
    } while(deep && element && i < arrayCount);

    if (array) free(array);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x4(%rsp)
movq %rsi, 0x8(%rsp)
movq (%rdi), %rbx
pushq $0x18
popq %rdi
callq 0x3130
movq %rax, %r14
movq %rax, %rdi
callq 0x7ada
pushq $0x8
popq %rdi
pushq $0x40
popq %rsi
callq 0x30f0
movq %rax, %r13
xorl %r12d, %r12d
testq %rax, %rax
setne %r12b
shll $0x6, %r12d
movq %rbx, (%rax)
xorl %eax, %eax
xorl %r15d, %r15d
movq %rax, 0x10(%rsp)
movq (%r13,%rax,8), %rdi
movq 0x8(%rsp), %rsi
callq 0x3be0
movq %rax, %rbp
movslq %r15d, %rbx
testq %rax, %rax
je 0x7d80
pushq $0x8
popq %rdi
callq 0x3130
movq %rbp, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x7b74
cmpb $0x0, 0x4(%rsp)
je 0x7d6c
testq %r13, %r13
je 0x7d6c
cmpl %r12d, %r15d
jl 0x7d64
movslq %r12d, %rsi
shlq $0x4, %rsi
movq %r13, %rdi
callq 0x3270
testq %rax, %rax
setne %cl
shll %cl, %r12d
testq %rax, %rax
je 0x7d7b
movq %rax, %r13
incl %r15d
movq %rbp, (%r13,%rbx,8)
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
callq 0x3c54
jmp 0x7d12
xorl %r13d, %r13d
jmp 0x7d6c
cmpb $0x0, 0x4(%rsp)
movq 0x10(%rsp), %rax
je 0x7d98
incq %rax
cmpq %rbx, %rax
jl 0x7cfe
movq %r13, %rdi
callq 0x31a0
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: FindByAttribute(TiHtmlElement*, char const*, char const*, bool)
TiHtmlResult* FindByAttribute( TiHtmlElement* htmlElement, const char* name, const char* value, bool deep ) {
    TiXmlElement* element = (TiXmlElement* )htmlElement->internal;
    TiXmlElement* node = NULL;
    TiHtmlResult* result = new TiHtmlResult();

    int arrayCount = 0;
    int arrayCapacity = 0;
    TiXmlElement** array = (TiXmlElement** )calloc(sizeof(TiXmlElement* ), MIN_CAPACITY);
    if (array) arrayCapacity = MIN_CAPACITY;
    int i = 0;

    /* 广度优先遍历 */
    array[i] = element;
    do {
        element = array[i];
        TIXML_FOR_EACH_ALL(element, node) {
            const char* aValue = node->Attribute(name);

            //add to array
            if (deep && array) {
                if (arrayCount >= arrayCapacity) {
                    array = (TiXmlElement** )realloc(array, sizeof(TiXmlElement* )*arrayCapacity*2);
                    if (array) arrayCapacity *= 2;
                }

                if (array) {
                    array[arrayCount++] = node;
                }
            }

            if (aValue && 0 == strcasecmp(aValue, value)) {
                result->Append(new TiHtmlElement(node));
            }
        }

        i++;
    } while(deep && element && i < arrayCount);

    if (array) free(array);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, 0x4(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, 0x20(%rsp)
movq (%rdi), %rbx
pushq $0x18
popq %rdi
callq 0x3130
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x7ada
pushq $0x8
popq %rdi
pushq $0x40
popq %rsi
callq 0x30f0
movq %rax, %rbp
xorl %r14d, %r14d
testq %rax, %rax
setne %r14b
shll $0x6, %r14d
movq %rbx, (%rax)
xorl %eax, %eax
xorl %r15d, %r15d
movq %rax, 0x10(%rsp)
movq (%rbp,%rax,8), %rdi
callq 0x3bae
movq %rax, %r13
movslq %r15d, %rbx
testq %rax, %rax
je 0x7eb0
movq %r13, %rdi
movq 0x20(%rsp), %rsi
callq 0x3eb2
movq %rax, %r12
cmpb $0x0, 0x4(%rsp)
je 0x7e71
testq %rbp, %rbp
je 0x7e71
cmpl %r14d, %r15d
jl 0x7e69
movslq %r14d, %rsi
shlq $0x4, %rsi
movq %rbp, %rdi
callq 0x3270
testq %rax, %rax
setne %cl
shll %cl, %r14d
testq %rax, %rax
je 0x7eac
movq %rax, %rbp
incl %r15d
movq %r13, (%rbp,%rbx,8)
testq %r12, %r12
je 0x7e9f
movq %r12, %rdi
movq 0x18(%rsp), %rsi
callq 0x3160
testl %eax, %eax
jne 0x7e9f
pushq $0x8
popq %rdi
callq 0x3130
movq %r13, (%rax)
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x7b74
movq %r13, %rdi
callq 0x3c2a
jmp 0x7e19
xorl %ebp, %ebp
jmp 0x7e71
cmpb $0x0, 0x4(%rsp)
movq 0x10(%rsp), %rax
je 0x7ec8
incq %rax
cmpq %rbx, %rax
jl 0x7e0a
movq %rbp, %rdi
callq 0x31a0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: TiHtmlDocument::ParseData(char const*)
bool TiHtmlDocument::ParseData( const char * data ) {
    if (data){ 
        TiXmlDocument* doc = (TiXmlDocument* )internal;
        doc->Parse(data);
        if (doc->Error()) return false;
        return true;
    }
    
    return false;
}

// Assembly:
testq %rsi, %rsi
je 0x8112
pushq %rbx
movq 0x8(%rdi), %rbx
movq (%rbx), %rax
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x18(%rax)
movb 0x50(%rbx), %al
xorb $0x1, %al
popq %rbx
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallmuou[P]tinyhtml/tinyhtml.cpp
// Function: TiHtmlDocument::Query(char const*)
TiHtmlResult* TiHtmlDocument::Query( const char* query ) {
    TiXmlDocument* doc = (TiXmlDocument* )internal;
    TiXmlElement* rootElement = doc ? doc ->RootElement():NULL;
    TiHtmlElement* element = new TiHtmlElement(rootElement);
    TiHtmlResult* result = element->Query(query);
    delete(element);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x8164
callq 0x3bae
movq %rax, %r14
jmp 0x8167
xorl %r14d, %r14d
pushq $0x8
popq %r15
movq %r15, %rdi
callq 0x3130
movq %rax, %r12
movq %r14, (%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7ee4
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0x3140
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::checkIfValueIsIdentifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Variable::checkIfValueIsIdentifier(std::string code)
{
    std::string value;
    bool start{ false };
    int whiteSpaceCount{ 0 };
    for(const auto &c : code) 
    {    
         if (start)
            value += c;    

        if (c == ' ')
             ++whiteSpaceCount;

        if (whiteSpaceCount == 2)
            start = true;
        
    } 
    if (value.at(0) == '"')
        return false;
    
    char valueChar[value.length() + 1]; 
    std::strcpy(valueChar, value.c_str());    
    
    if (static_cast<int>(valueChar[0]) > 57)
        return true;
    
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rsi), %r14
movq 0x8(%rsi), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebx, %ebx
cmpq %r12, %r15
je 0x2c69
testb $0x1, %bl
je 0x2c4e
movsbl (%r14,%r12), %esi
leaq -0x48(%rbp), %rdi
callq 0x2140
xorl %eax, %eax
cmpb $0x20, (%r14,%r12)
sete %al
addl %eax, %r13d
cmpl $0x2, %r13d
sete %al
orb %al, %bl
incq %r12
jmp 0x2c36
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x2290
cmpb $0x22, (%rax)
jne 0x2c7d
xorl %ebx, %ebx
jmp 0x2caf
movq %rsp, %r14
movq -0x40(%rbp), %rbx
movq %rsp, %r15
addq $0x10, %rbx
andq $-0x10, %rbx
movq %r15, %rdi
subq %rbx, %rdi
movq %rdi, %rsp
negq %rbx
movq -0x48(%rbp), %rsi
callq 0x2170
cmpb $0x3a, (%r15,%rbx)
setge %bl
movq %r14, %rsp
leaq -0x48(%rbp), %rdi
callq 0x20c0
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2ccb
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::getValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string Variable::getValue(std::string code)
{
    std::string value;
    bool start{ false };
    int whiteSpaceCount{ 0 };
    for(const auto &c : code) 
    {    
         if (start)
            value += c;    

        if (c == ' ')
             ++whiteSpaceCount;

        if (whiteSpaceCount == 2)
            start = true;
        
    } 
    std::string stringValue;
    if (value.at(0) == '"')
    {
        for (int i{ 1 }; i < value.length() - 1; ++i)
        {
           stringValue += value.at(i); 
        } 
        value = stringValue;
    }
    return value; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rdx), %r14
movq 0x8(%rdx), %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
xorl %r13d, %r13d
cmpq %r12, %r15
je 0x2d42
testb $0x1, %r13b
je 0x2d28
movsbl (%r14,%r12), %esi
movq %rbx, %rdi
callq 0x2140
xorl %eax, %eax
cmpb $0x20, (%r14,%r12)
sete %al
addl %eax, %ebp
cmpl $0x2, %ebp
sete %al
orb %al, %r13b
incq %r12
jmp 0x2d10
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2290
cmpb $0x22, (%rax)
jne 0x2d9f
pushq $0x1
popq %r14
leaq 0x8(%rsp), %r15
movq 0x8(%rbx), %rax
decq %rax
cmpq %r14, %rax
jbe 0x2d92
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2290
movsbl (%rax), %esi
movq %r15, %rdi
callq 0x2140
incq %r14
jmp 0x2d6b
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x20c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2dc2
movq %rax, %r14
jmp 0x2dcf
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::getIdentifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string Variable::getValueVar(std::string identifier)
{
    for (int i{ 0 }; i < m_variables.size(); ++i)
    {
        if (m_variables.at(i).identifier == identifier)
            return m_variables.at(i).value;
    } 
    std::cout << "Get value: identifier not found\n";
    return "smt went wrong";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movb $0x0, (%rax)
movq (%rdx), %r12
movq 0x8(%rdx), %r13
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
xorl %r15d, %r15d
cmpq %rbp, %r13
je 0x2e41
movb (%r12,%rbp), %al
cmpb $0x20, %al
jne 0x2e2b
testb $0x1, %r15b
movb $0x1, %r15b
je 0x2e3c
jmp 0x2e57
testb $0x1, %r15b
je 0x2e3c
movsbl %al, %esi
movq %r14, %rdi
callq 0x2140
incq %rbp
jmp 0x2e13
leaq 0x720d(%rip), %rsi      # 0xa055
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x57ec
jmp 0x2e9a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %rdx
cmpq %rdx, %rcx
je 0x2e7b
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x2e81
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rdx, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x20c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2eb8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::printValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Variable::printValue(std::string identifier)
{
    for (int i{ 0 }; i < m_variables.size(); ++i)
    {
        if (m_variables.at(i).identifier == identifier)
        {
            std::cout << m_variables.at(i).value << std::endl;
            return; 
        }
    } 
    std::cerr << "Print: identifier not found" << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
pushq $-0x1
popq %r14
pushq $0x48
popq %r12
incq %r14
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r12
cmpq %r14, %rax
jbe 0x3000
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5828
leaq 0x28(%rax), %rdi
movq %r15, %rsi
callq 0x27e7
testb %al, %al
je 0x2fb4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5828
leaq 0x8(%rax), %rsi
movq 0xafbf(%rip), %rdi      # 0xdfb8
callq 0x2160
jmp 0x3013
movq 0xafe9(%rip), %rdi      # 0xdff0
leaq 0x705c(%rip), %rsi      # 0xa06a
callq 0x2180
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::setVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Variable::Types)
void Variable::setVariable(std::string identifier, std::string value, Types type)
{
    for (int i{ 0 }; i < m_variables.size(); ++i)
    {
        if (m_variables.at(i).identifier == identifier)
        {
            m_variables.at(i).value = value; 
            m_variables.at(i).type = type; 
            return;
        }
    } 
    
    TypeValue typeValue; 
    typeValue.identifier = identifier;
    typeValue.value = value;
    typeValue.type = type; 
    
    m_variables.push_back(typeValue);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
pushq $-0x1
popq %r13
pushq $0x48
popq %rbp
incq %r13
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
idivq %rbp
cmpq %r13, %rax
jbe 0x309b
movq %r14, %rdi
movq %r13, %rsi
callq 0x5828
leaq 0x28(%rax), %rdi
movq %r12, %rsi
callq 0x27e7
testb %al, %al
je 0x3046
movq %r14, %rdi
movq %r13, %rsi
callq 0x5828
leaq 0x8(%rax), %rdi
movq %r15, %rsi
callq 0x20f0
movq %r14, %rdi
movq %r13, %rsi
callq 0x5828
movl %ebx, (%rax)
jmp 0x30ec
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
movq %r12, %rsi
callq 0x20f0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x20f0
movq %rsp, %rsi
movl %ebx, (%rsi)
movq %r14, %rdi
callq 0x5846
movq %rsp, %rdi
callq 0x5872
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5872
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::compareVariable(Variable const&)
void Variable::compareVariable(const Variable &variable)
{
    for (int i{ 0 }; i < variable.m_variables.size(); ++i)
    {
        for (int j{ 0 }; j < m_variables.size(); ++j)
        {
            if (m_variables.at(j).identifier == variable.m_variables.at(i).identifier)
            {
                m_variables.at(j).type = variable.m_variables.at(i).type;
                m_variables.at(j).value = variable.m_variables.at(i).value;
            } 
        } 

    } 
   
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
pushq $0x48
popq %rbp
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %rbp
cmpq %r15, %rax
jbe 0x3268
xorl %r12d, %r12d
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
idivq %rbp
cmpq %r12, %rax
jbe 0x3260
movq %r14, %rdi
movq %r12, %rsi
callq 0x5828
leaq 0x28(%rax), %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0x588c
leaq 0x28(%rax), %rsi
movq %r13, %rdi
callq 0x27e7
testb %al, %al
je 0x3258
movq %rbx, %rdi
movq %r15, %rsi
callq 0x588c
movl (%rax), %r13d
movq %r14, %rdi
movq %r12, %rsi
callq 0x5828
movl %r13d, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x588c
leaq 0x8(%rax), %r13
movq %r14, %rdi
movq %r12, %rsi
callq 0x5828
leaq 0x8(%rax), %rdi
movq %r13, %rsi
callq 0x20f0
incq %r12
jmp 0x31db
incq %r15
jmp 0x31c3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Manuel123cool[P]smiley/read_variable.cpp
// Function: Variable::getTypeByIdent(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Variable::Types Variable::getTypeByIdent(std::string identifier)
{
    for (int i{ 0 }; i < m_variables.size(); ++i)
    {
        if (m_variables.at(i).identifier == identifier)
            return m_variables.at(i).type;
    } 
    return STRING;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r14
pushq $-0x1
popq %r15
pushq $0x48
popq %r13
pushq $0x1
popq %rbx
incq %r15
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
idivq %r13
cmpq %r15, %rax
jbe 0x32ce
movq %r14, %rdi
movq %r15, %rsi
callq 0x5828
leaq 0x28(%rax), %rdi
movq %r12, %rsi
callq 0x27e7
testb %al, %al
je 0x3292
movq %r14, %rdi
movq %r15, %rsi
callq 0x5828
movl (%rax), %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Manuel123cool[P]smiley/regex.cpp
// Function: MyRegex::testUserInput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Stack&)
void MyRegex::testUserInput(std::string code, Stack &stack)
{
    if (code.length() <= 0)
        return;  

    if (!MyRegex::testString(code, "B-) "))
        return;

    std::string identifier;
    bool start{ false };
    for(const auto &c : code)
    {
        if (start)
            identifier += c;
   
        if (c == ' ' && !start)
            start = true;
    }

    std::string inputValue;
    std::getline(std::cin, inputValue);
    stack().setVariable(identifier, inputValue, Variable::STRING);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
cmpq $0x0, 0x8(%rdi)
je 0x657e
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa8(%rsp), %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x3d5c(%rip), %rsi      # 0xa1bc
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x57ec
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x5ddc
movl %eax, %ebp
leaq 0x88(%rsp), %rdi
callq 0x20c0
leaq 0xa8(%rsp), %rdi
callq 0x20c0
testb %bpl, %bpl
je 0x657e
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%r14), %r15
movq 0x8(%r14), %r12
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
xorl %ebp, %ebp
cmpq %r13, %r12
je 0x64f6
testb $0x1, %bpl
je 0x64e6
movsbl (%r15,%r13), %esi
movq %r14, %rdi
callq 0x2140
cmpb $0x20, (%r15,%r13)
sete %al
orb %al, %bpl
incq %r13
jmp 0x64ce
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x7aca(%rip), %rdi      # 0xdfd8
leaq 0x28(%rsp), %rsi
callq 0x2040
movq %rbx, %rdi
callq 0x77fe
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x21e0
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x21e0
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
callq 0x3026
leaq 0x48(%rsp), %rdi
callq 0x20c0
leaq 0x68(%rsp), %rdi
callq 0x20c0
leaq 0x28(%rsp), %rdi
callq 0x20c0
leaq 0x8(%rsp), %rdi
callq 0x20c0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20c0
jmp 0x65a2
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x20c0
jmp 0x65d0
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x20c0
jmp 0x65c3
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
jmp 0x65e4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20c0
jmp 0x65df
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/Manuel123cool[P]smiley/stack.cpp
// Function: Stack::addStackFrame()
void Stack::addStackFrame()
{
    Variable var;
    if (m_stack.size() > 0)
    {
        var = m_stack.at(m_stack.size() - 1);
    }
    m_stack.push_back(var);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x8(%rdi), %rax
subq (%rdi), %rax
je 0x777d
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq -0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x791e
movq %rsp, %rdi
movq %rax, %rsi
callq 0x797c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x793c
movq %rsp, %rdi
callq 0x7c8a
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7c8a
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/Manuel123cool[P]smiley/stack.cpp
// Function: Stack::checkBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Stack::checkBlock(std::string code)
{
    if (code.length() <= 0)
        return;

    bool blockStart{ MyRegex::testString(code, "><") };
    bool blockEnd{ MyRegex::testString(code, "<>") };
    
    if (blockStart)
        addStackFrame();          
    
    if (blockEnd)
       popStackFrame(); 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
cmpq $0x0, 0x8(%rsi)
je 0x78e2
movq %rsi, %r15
movq %rdi, %r14
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0x21e0
leaq 0x2ab1(%rip), %rsi      # 0xa2f9
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x57ec
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5ddc
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x20c0
leaq 0x68(%rsp), %rdi
callq 0x20c0
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21e0
leaq 0x2a69(%rip), %rsi      # 0xa2fc
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x57ec
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5ddc
movl %eax, %r15d
leaq 0x8(%rsp), %rdi
callq 0x20c0
leaq 0x48(%rsp), %rdi
callq 0x20c0
testb %bpl, %bpl
je 0x78d5
movq %r14, %rdi
callq 0x7740
testb %r15b, %r15b
je 0x78e2
movq %r14, %rdi
callq 0x77aa
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x7904
jmp 0x790b
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x20c0
jmp 0x790e
movq %rax, %r14
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/Manuel123cool[P]smiley/instruction.cpp
// Function: Instruction::checkJumps(int)
int Instruction::checkJumps(int num)
{
    for (int i{ 0 }; i < m_jumps.size(); ++i)
    {
        int startNum = m_jumps.at(i).start;
        if (startNum == num)
        {
            int jumpTo{ m_jumps.at(i).jumpTo };
            for (int j{ 0 }; j < m_jumps.size(); ++j)
            {
                if (m_jumps.at(j).start == startNum && m_jumps.at(j).jumpTo == jumpTo)
                    m_jumps.erase(m_jumps.begin() + j);
            }
            return jumpTo;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
pushq $-0x1
popq %rbp
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x89b1
movq %r14, %rdi
movq %r15, %rsi
callq 0x9504
cmpl %ebx, (%rax)
je 0x8957
incq %r15
jmp 0x8933
movq %r14, %rdi
movq %r15, %rsi
callq 0x9504
movl 0x4(%rax), %ebp
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x89b1
movq %r14, %rdi
movq %r15, %rsi
callq 0x9504
cmpl %ebx, (%rax)
jne 0x89a8
movq %r14, %rdi
movq %r15, %rsi
callq 0x9504
cmpl %ebp, 0x4(%rax)
jne 0x89a8
movq (%r14), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x9526
incq %r15
addq $0x8, %r12
jmp 0x896b
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: NormalizedColor(gaps::R3MeshVertex*)
static RNRgb 
NormalizedColor(R3MeshVertex *vertex)
{
  // Check color scheme
  RNRgb c(0, 0, 0);
  if (color_with_labels) {
    // Color with deterministic value based on int label
    int ivalue = (current_property->VertexValue(vertex) + 0.5);
    c[0] = (ivalue % 7) / 6.0;
    c[1] = (ivalue % 5) / 4.0;
    c[2] = (ivalue % 2) / 1.0;
  }
  else {
    // Compute normalized value
    RNScalar value = NormalizedValue(vertex);
    if (flip_color_range) value = 1.0 - value;
    
    // Compute color
    if (color_with_redness) {
      c[0] = 0.8;
      c[1] = 0.8 * (1 - value);
      c[2] = 0.8 * (1 - value);
    }
    else {
      if (value < 0.5) {
        c[0] = 1 - 2 * value;
        c[1] = 2 * value;
      }
      else {
        c[1] = 1 - 2 * (value - 0.5);
        c[2] = 2 * (value - 0.5);
      }
    }
  }
  
  // Return color
  return c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
xorps %xmm1, %xmm1
xorpd %xmm2, %xmm2
callq 0x7fe96
cmpb $0x1, 0x11450f(%rip)    # 0x139a0c
jne 0x25561
movq 0x11449a(%rip), %rax    # 0x1399a0
movslq 0x70(%r14), %rcx
movq 0x410(%rax), %rax
movsd (%rax,%rcx,8), %xmm0
addsd 0xa3b32(%rip), %xmm0    # 0xc9050
cvttsd2si %xmm0, %ecx
pushq $0x7
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
cvtsi2sd %edx, %xmm0
divsd 0xa3b32(%rip), %xmm0    # 0xc9068
movsd %xmm0, (%rbx)
pushq $0x5
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
cvtsi2sd %edx, %xmm0
mulsd 0xa3b22(%rip), %xmm0    # 0xc9070
movsd %xmm0, 0x8(%rbx)
pushq $0x2
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
cvtsi2sd %edx, %xmm1
jmp 0x255ad
movq %r14, %rdi
callq 0x255fc
movsd 0xa3aaf(%rip), %xmm1    # 0xc9020
cmpb $0x0, 0x114490(%rip)    # 0x139a08
je 0x25586
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movapd %xmm2, %xmm0
cmpb $0x1, 0x1143f7(%rip)    # 0x139984
jne 0x255b2
movabsq $0x3fe999999999999a, %rax # imm = 0x3FE999999999999A
movq %rax, (%rbx)
subsd %xmm0, %xmm1
mulsd 0xa3a68(%rip), %xmm1    # 0xc9010
movsd %xmm1, 0x8(%rbx)
pushq $0x10
popq %rax
jmp 0x255ec
movsd 0xa3a96(%rip), %xmm2    # 0xc9050
ucomisd %xmm0, %xmm2
jbe 0x255d0
addsd %xmm0, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
pushq $0x8
jmp 0x255e7
addsd 0xa3a88(%rip), %xmm0    # 0xc9060
addsd %xmm0, %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rbx)
pushq $0x10
popq %rax
movapd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: NormalizedValue(gaps::R3MeshVertex*)
static RNScalar
NormalizedValue(R3MeshVertex *vertex)
{
  // Return value between 0 and 1
  RNScalar value = current_property->VertexValue(vertex);
  RNScalar diameter = value_range.Diameter();
  if (diameter > 0) value = (value - value_range.Min()) / diameter;
  if (value < 0) value = 0;
  else if (value > 1) value = 1;
  return value;
}

// Assembly:
movq 0x11439d(%rip), %rax    # 0x1399a0
movslq 0x70(%rdi), %rcx
movq 0x410(%rax), %rax
movsd (%rax,%rcx,8), %xmm0
movsd 0x11431d(%rip), %xmm2   # 0x139938
movsd 0x11430d(%rip), %xmm3   # 0x139930
subsd %xmm3, %xmm2
xorpd %xmm1, %xmm1
cmpltsd %xmm2, %xmm1
movapd %xmm1, %xmm4
andnpd %xmm0, %xmm4
movapd %xmm0, %xmm5
subsd %xmm3, %xmm5
divsd %xmm2, %xmm5
xorpd %xmm0, %xmm0
andpd %xmm5, %xmm1
orpd %xmm4, %xmm1
ucomisd %xmm1, %xmm0
ja 0x2566c
ucomisd 0xa39c2(%rip), %xmm1    # 0xc9020
movapd %xmm1, %xmm0
jbe 0x2566c
movsd 0xa39b4(%rip), %xmm0    # 0xc9020
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: GLUTResize(int, int)
void GLUTResize(int w, int h)
{
  // Resize window
  glViewport(0, 0, w, h);

  // Resize viewer viewport
  viewer->ResizeViewport(0, 0, w, h);

  // Remember window size 
  GLUTwindow_width = w;
  GLUTwindow_height = h;

  // Redraw
  glutPostRedisplay();
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
xorl %edi, %edi
xorl %esi, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x21210
movq 0x1142d0(%rip), %rdi    # 0x139958
xorl %esi, %esi
xorl %edx, %edx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x26cea
movl %ebp, 0x10f334(%rip)    # 0x1349d0
movl %ebx, 0x10f32a(%rip)    # 0x1349cc
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbc5e4
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: GLUTMotion(int, int)
void GLUTMotion(int x, int y)
{
  // Invert y coordinate
  y = GLUTwindow_height - y;

  // Compute mouse movement
  int dx = x - GLUTmouse[0];
  int dy = y - GLUTmouse[1];
  
  // World in hand navigation 
  if (GLUTbutton[0]) viewer->RotateWorld(1.0, world_origin, x, y, dx, dy);
  else if (GLUTbutton[1]) viewer->ScaleWorld(1.0, world_origin, x, y, dx, dy);
  else if (GLUTbutton[2]) viewer->TranslateWorld(1.0, world_origin, x, y, dx, dy);
  if (GLUTbutton[0] || GLUTbutton[1] || GLUTbutton[2]) glutPostRedisplay();

  // Remember mouse position 
  GLUTmouse[0] = x;
  GLUTmouse[1] = y;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movl 0x10f314(%rip), %ebx    # 0x1349cc
subl %esi, %ebx
movl %edi, %r8d
subl 0x1142fc(%rip), %r8d    # 0x1399c0
movl %ebx, %r9d
subl 0x1142f6(%rip), %r9d    # 0x1399c4
cmpl $0x0, 0x1142f3(%rip)    # 0x1399c8
je 0x256db
pushq $0x58
jmp 0x256f3
cmpl $0x0, 0x1142ea(%rip)    # 0x1399cc
je 0x256e8
pushq $0x50
jmp 0x256f3
cmpl $0x0, 0x1142e1(%rip)    # 0x1399d0
je 0x25715
pushq $0x48
popq %rax
movq 0x11425d(%rip), %rdi    # 0x139958
movq (%rdi), %r10
leaq 0x11423b(%rip), %rsi    # 0x139940
movsd 0xa3913(%rip), %xmm0    # 0xc9020
movl %ebp, %edx
movl %ebx, %ecx
callq *(%r10,%rax)
cmpl $0x0, 0x1142ac(%rip)    # 0x1399c8
jne 0x25730
cmpl $0x0, 0x1142a7(%rip)    # 0x1399cc
jne 0x25730
cmpl $0x0, 0x1142a2(%rip)    # 0x1399d0
je 0x25735
callq 0xbc5e4
movl %ebp, 0x114285(%rip)    # 0x1399c0
movl %ebx, 0x114283(%rip)    # 0x1399c4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: GLUTMouse(int, int, int, int)
void GLUTMouse(int button, int state, int x, int y)
{
  // Invert y coordinate
  y = GLUTwindow_height - y;
  
  // Process mouse button event
  // Process mouse button event
  if ((button == GLUT_LEFT) && (state == GLUT_UP)) {
    // Check for double click  
    static RNBoolean double_click = FALSE;
    static RNTime last_mouse_down_time;
    double_click = (!double_click) && (last_mouse_down_time.Elapsed() < 0.4);
    last_mouse_down_time.Read();

    // Set world origin
    if (double_click) {
      R3Ray ray = viewer->WorldRay(x, y);
      R3MeshIntersection intersection;
      if (mesh->Intersection(ray, &intersection)) {
        world_origin = intersection.point;
      }
    }
  }

  // Remember button state 
  int b = (button == GLUT_LEFT_BUTTON) ? 0 : ((button == GLUT_MIDDLE_BUTTON) ? 1 : 2);
  GLUTbutton[b] = (state == GLUT_DOWN) ? 1 : 0;

  // Remember modifiers 
  GLUTmodifiers = glutGetModifiers();

   // Remember mouse position 
  GLUTmouse[0] = x;
  GLUTmouse[1] = y;

  // Redraw
  glutPostRedisplay();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %ebp
movl 0x10f268(%rip), %r13d   # 0x1349cc
subl %ecx, %r13d
movl %esi, %eax
xorl $0x1, %eax
orl %edi, %eax
jne 0x2581a
movb 0x11426e(%rip), %al     # 0x1399e8
testb %al, %al
je 0x25861
xorl %eax, %eax
cmpl $0x0, 0x114249(%rip)    # 0x1399d4
jne 0x257aa
leaq 0x114244(%rip), %rdi    # 0x1399d8
callq 0x7fb10
movsd 0xa38d7(%rip), %xmm1    # 0xc9078
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
movl %eax, 0x114224(%rip)    # 0x1399d4
leaq 0x114221(%rip), %rdi    # 0x1399d8
callq 0x26a28
cmpl $0x0, 0x114211(%rip)    # 0x1399d4
je 0x2581a
movq 0x11418c(%rip), %rsi    # 0x139958
cvtsi2sd %ebx, %xmm0
cvtsi2sd %r13d, %xmm1
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x278a0
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x6f6ca
movq 0x114172(%rip), %rdi    # 0x139968
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movq %r12, %rsi
callq *0x170(%rax)
testl %eax, %eax
je 0x2581a
leaq 0x11412e(%rip), %rdi    # 0x139940
movq %r15, %rsi
callq 0x6f9b6
xorl %eax, %eax
cmpl $0x1, %ebp
setne %al
incl %eax
xorl %ecx, %ecx
testl %r14d, %r14d
sete %cl
testl %ebp, %ebp
cmovel %ebp, %eax
leaq 0x114190(%rip), %rdx    # 0x1399c8
movl %ecx, (%rdx,%rax,4)
callq 0xc1082
movl %ebx, 0x11417a(%rip)    # 0x1399c0
movl %r13d, 0x114177(%rip)   # 0x1399c4
callq 0xbc5e4
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x114180(%rip), %rdi    # 0x1399e8
callq 0x22130
testl %eax, %eax
je 0x25782
leaq 0x11415c(%rip), %rdi    # 0x1399d8
callq 0x7fad6
leaq 0x114160(%rip), %rdi    # 0x1399e8
callq 0x215b0
jmp 0x25782
movq %rax, %rbx
leaq 0x11414c(%rip), %rdi    # 0x1399e8
callq 0x21590
movq %rbx, %rdi
callq 0x220c0
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: SelectProperty(int)
static void
SelectProperty(int property_index)
{
  // Set current property index
  current_property_index = property_index;
  if (current_property_index < 0) current_property_index = 0;
  if (current_property_index >= properties->NProperties()) current_property_index = properties->NProperties() - 1;

  // Get current property
  current_property = properties->Property(current_property_index);

  // Set value range
  if (input_value_range.Diameter() > 0) {
    value_range = input_value_range;
  }
  else {
    percentile_range.Reset(10, 90);
    RNScalar min_value = current_property->Percentile(percentile_range.Min());
    RNScalar max_value = current_property->Percentile(percentile_range.Max());
    value_range.Reset(min_value, max_value);
  }
}

// Assembly:
xorl %eax, %eax
testl %edi, %edi
cmovgl %edi, %eax
movl %eax, 0x113fa4(%rip)    # 0x1399f0
movq 0x113f5d(%rip), %rcx    # 0x1399b0
movl 0x14(%rcx), %edx
cmpl %edx, %eax
jl 0x25a64
decl %edx
movl %edx, 0x113f8e(%rip)    # 0x1399f0
movl %edx, %eax
movq 0x8(%rcx), %rcx
cltq
movq (%rcx,%rax,8), %rdi
movq %rdi, 0x113f2b(%rip)    # 0x1399a0
movsd 0x113e83(%rip), %xmm0   # 0x139900
ucomisd 0x113e73(%rip), %xmm0   # 0x1398f8
jbe 0x25a96
movups 0x113e6a(%rip), %xmm0   # 0x1398f8
movups %xmm0, 0x113e9b(%rip)   # 0x139930
retq
pushq %rax
movaps 0xa36e2(%rip), %xmm0    # 0xc9180
movaps %xmm0, 0x113e7b(%rip)   # 0x139920
movsd 0xa358b(%rip), %xmm0    # 0xc9038
callq 0x43578
movsd %xmm0, (%rsp)
movq 0x113ee2(%rip), %rdi    # 0x1399a0
movsd 0x113e62(%rip), %xmm0   # 0x139928
callq 0x43578
movsd (%rsp), %xmm1
movsd %xmm1, 0x113e58(%rip)   # 0x139930
movsd %xmm0, 0x113e58(%rip)   # 0x139938
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/prpview/prpview.cpp
// Function: GLUTMainLoop()
void GLUTMainLoop(void)
{
  // Initialize world origin
  if (initial_world_origin != R3unknown_point) {
    world_origin = initial_world_origin;
  }
  else {
    world_origin = mesh->BBox().Centroid();
  }

  // Initialize current property
  SelectProperty(initial_property_index);

  // Run main loop -- never returns 
  glutMainLoop();
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x113bc0(%rip), %rdi    # 0x139908
leaq 0x117151(%rip), %rsi    # 0x13cea0
callq 0x6f7c2
testl %eax, %eax
je 0x25d68
leaq 0x113be1(%rip), %rdi    # 0x139940
leaq 0x113ba2(%rip), %rsi    # 0x139908
jmp 0x25d92
movq 0x113bf9(%rip), %rsi    # 0x139968
movq 0xf8(%rsi), %rax
addq $0xf8, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq *0x68(%rax)
leaq 0x113bb1(%rip), %rdi    # 0x139940
movq %rbx, %rsi
callq 0x6f9b6
movl 0x113c57(%rip), %edi    # 0x1399f4
callq 0x25a3f
callq 0xbf5d7
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::R3MeshPropertySet(gaps::R3MeshPropertySet const&)
R3MeshPropertySet::
R3MeshPropertySet(const R3MeshPropertySet& set)
  : mesh(set.mesh),
    properties()
{
  // Copy properties
  for (int i = 0; i < set.NProperties(); i++) {
    R3MeshProperty *property = set.Property(i);
    Insert(new R3MeshProperty(*property));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x8001e
xorl %r13d, %r13d
movslq 0x14(%r14), %rax
cmpq %rax, %r13
jge 0x41301
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %r12
movl $0x448, %edi            # imm = 0x448
callq 0x218c0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x42bdc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26aa0
incq %r13
jmp 0x412c8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x448, %esi            # imm = 0x448
movq %r15, %rdi
callq 0x218e0
jmp 0x41320
movq %rax, %r14
movq %rbx, %rdi
callq 0x8008c
movq %r14, %rdi
callq 0x220c0
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/pkgs/R3Shapes/R3MeshPropertySet.cpp
// Function: gaps::R3MeshPropertySet::PropertyIndex(char const*) const
int R3MeshPropertySet::
PropertyIndex(const char *property_name) const
{
  // Search through properties for matching name
  for (int i = 0; i < NProperties(); i++) {
    R3MeshProperty *property = Property(i);
    if (!strcmp(property->Name(), property_name)) return i;
  }

  // Not found
  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl 0x14(%rdi), %r15d
movq 0x8(%rdi), %r12
xorl %r14d, %r14d
testl %r15d, %r15d
cmovlel %r14d, %r15d
pushq $-0x1
popq %rbp
cmpq %r14, %r15
je 0x413c9
movq (%r12,%r14,8), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0x21d10
testl %eax, %eax
je 0x413c6
incq %r14
jmp 0x413a8
movl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq