LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::doTokenize()
void doTokenize () {
        while (true) {
          Token token = getNext();
          if (token.type == TOKEN_EOF || token.type == TOKEN_UNKNOWN) {
            break;
          }

          addToken(token);
        }

        addToken(makeToken(TOKEN_EOF));
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
leaq 0x60(%rdi), %r14
leaq 0x50(%rsp), %rbp
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x6dd2
xorl %r13d, %r13d
movl 0x38(%rsp), %eax
testl %eax, %eax
je 0x6c18
cmpl $0x72, %eax
je 0x6c18
movl %eax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x35cc
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
callq 0x77c6
movl 0x8(%rsp), %eax
movl %eax, 0x78(%rbx)
movq 0x10(%rsp), %rdi
movb $0x1, %r13b
cmpq %r15, %rdi
je 0x6c18
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6c2f
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2200
testb %r13b, %r13b
jne 0x6ba5
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x72, %edx
callq 0x6f9c
movq %r14, %rdi
movq %r15, %rsi
callq 0x77c6
leaq 0x80(%rsp), %rax
movl -0x18(%rax), %ecx
movl %ecx, 0x78(%rbx)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c7f
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x2200
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ce5
movq 0x80(%rsp), %rsi
jmp 0x6cdd
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x6cce
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x6cce
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6ce5
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::skipWhitespace()
bool skipWhitespace () {
        while (true) {
          const char c = _input[_position];
          
          if (c == '\0') {
            return false;
          }

          if (c != ' ' && c != '\r' && c != '\n' && c != '\t' && c != '\f' && c != '\b') {
            return true;
          }

          if (c == '\r') {
            if (_input[_position + 1] == '\n') {
              ++_position;
              ++_line;
            }
          }
          else if (c == '\n') {
            ++_line;
          }

          _position++;
        }
      }

// Assembly:
movq 0x80(%rdi), %rax
movq 0x90(%rdi), %rcx
movq 0x98(%rdi), %rdx
leaq 0xfea(%rip), %rsi       # 0x8020
movzbl (%rax,%rcx), %r8d
cmpq $0xd, %r8
ja 0x7061
movslq (%rsi,%r8,4), %r8
addq %rsi, %r8
jmpq *%r8
cmpb $0xa, 0x1(%rax,%rcx)
jne 0x7067
incq %rcx
incq %rdx
movq %rdx, 0x98(%rdi)
jmp 0x7067
cmpl $0x20, %r8d
jne 0x7073
incq %rcx
movq %rcx, 0x90(%rdi)
jmp 0x7036
movb $0x1, %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::handleString(char)
Token handleString (const char terminator) {
        size_t now = _position + 1;

        while (true) {
          char n = _input[now];
          if (n == '\\') {
            ++now;
          }
          else if (n == terminator) {
            return makeToken(TOKEN_STRING_LITERAL, until(now + 1));
          }
          else if (n == '\0') {
            return makeToken(TOKEN_UNKNOWN);
          }
          ++now;
        }
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rsi), %rax
movq 0x90(%rsi), %rsi
movq %rsi, %rcx
movb 0x1(%rax,%rcx), %dil
cmpb $0x5c, %dil
jne 0x70ad
addq $0x2, %rcx
jmp 0x709c
cmpb %dl, %dil
je 0x70c9
incq %rcx
testb %dil, %dil
jne 0x709c
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6f9c
jmp 0x7115
addq %rax, %rsi
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq (%rax,%rcx), %rdx
addq $0x2, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x76ea
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
movq %r15, %rcx
callq 0x7670
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7115
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x713e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::handleId()
Token handleId () {
        // name/keyword
        std::string name;
        bool canBeKeyword = true;
        size_t now = _position;
        
        while (true) {
          char n = _input[now];

          if (n >= 'a' && n <= 'z') {
            name.push_back(n);
          } 
          else if (n >= 'A' && n <= 'Z') {
            name.push_back(n);
            canBeKeyword = false;
          }
          else if (n >= '0' && n <= '9') {
            name.push_back(n);
            canBeKeyword = false;
          }
          else if (n == '_' || n == '$') {
            name.push_back(n);
          }
          else {
            break;
          }
          ++now;
        }
          
        if (canBeKeyword) {
          std::map<std::string, TokenType>::const_iterator it = _keywordMap.find(name);
          if (it != _keywordMap.end()) {
            return makeToken((*it).second, std::string(_input + _position, name.size()));
          }
        }
          
        return makeToken(TOKEN_NAME, std::string(_input + _position, name.size()));
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x90(%rsi), %r13
movb $0x1, %bpl
leaq 0x28(%rsp), %r15
movq 0x80(%r14), %rsi
movzbl (%rsi,%r13), %eax
leal -0x61(%rax), %ecx
cmpb $0x1a, %cl
jae 0x71a2
movsbl %al, %esi
movq %r15, %rdi
callq 0x21b0
jmp 0x71c5
leal -0x41(%rax), %ecx
cmpb $0x1a, %cl
setae %cl
leal -0x30(%rax), %edx
cmpb $0xa, %dl
setae %dl
testb %dl, %cl
jne 0x71ca
movsbl %al, %esi
movq %r15, %rdi
callq 0x21b0
xorl %ebp, %ebp
incq %r13
jmp 0x7181
cmpl $0x5f, %eax
je 0x7195
cmpl $0x24, %eax
je 0x7195
testb $0x1, %bpl
je 0x7234
leaq 0x30(%r14), %rdi
leaq 0x28(%rsp), %rsi
callq 0x7780
leaq 0x38(%r14), %rdi
movq 0x80(%r14), %rsi
movq 0x90(%r14), %rcx
movq 0x30(%rsp), %rdx
cmpq %rdi, %rax
je 0x7240
movl 0x40(%rax), %ebp
addq %rcx, %rsi
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x76ea
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x7670
jmp 0x7271
movq 0x90(%r14), %rcx
movq 0x30(%rsp), %rdx
addq %rsi, %rcx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
addq %rcx, %rdx
leaq 0x8(%rsp), %rdi
movq %rcx, %rsi
callq 0x76ea
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4b, %edx
callq 0x7670
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7288
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x729f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x72b7
jmp 0x72d5
jmp 0x72d5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x72d8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x72d8
jmp 0x72d5
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x72ef
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::handleNumber()
Token handleNumber () {
        size_t now = _position;
        bool dotFound = false;
        bool expFound = false;
        
        while (true) {
          char n = _input[now];
          if (n >= '0' && n <= '9') {
            ++now;
          }
          else if (n == '.' && ! dotFound) {
            dotFound = true;
            ++now;
          }
          else if ((n == 'e' || n == 'E') && ! expFound) {
            // exponent
            expFound = true;
            ++now;
          }
          else {
            break;
          }
        }

        return makeToken(TOKEN_NUMBER, until(now));
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rsi), %rsi
movq 0x90(%r14), %rax
leaq (%rsi,%rax), %rdx
xorl %ecx, %ecx
xorl %edi, %edi
movb (%rdx), %r8b
leal -0x30(%r8), %r9d
cmpb $0xa, %r9b
jb 0x7354
cmpb $0x2e, %r8b
jne 0x733d
testb $0x1, %dil
movb $0x1, %dil
je 0x7354
jmp 0x7359
andb $-0x21, %r8b
cmpb $0x45, %r8b
setne %r8b
orb %cl, %r8b
movb $0x1, %cl
testb $0x1, %r8b
jne 0x7359
incq %rdx
jmp 0x731f
addq %rax, %rsi
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x76ea
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
movq %r15, %rcx
callq 0x7670
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x739d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x73c6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::handleCommentMulti()
Token handleCommentMulti () {
        size_t now = _position + 2;
        
        while (true) {
          char n1 = _input[now];
          char n2 = _input[now + 1];

          if (n1 == '\r' && n1 == '\n') {
            ++_line;
            now += 2;
          }
          else if (n1 == '\r' || n1 == '\n') {
            ++_line;
            ++now;
          }
          else if (n1 == '*' && n2 == '/') {
            return makeToken(TOKEN_COMMENT_MULTI, until(now + 2));
          }
          else if (n1 == '\0') {
            return makeToken(TOKEN_UNKNOWN);
          }
          else {
            ++now;
          }
        }
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rsi), %rsi
movq 0x90(%r14), %rax
leaq 0x2(%rax), %rcx
movq 0x98(%r14), %rdi
leaq 0x2(%rsi), %r8
leaq (%r8,%rcx), %rdx
incq %rcx
movzbl -0x2(%rdx), %r9d
cmpl $0xd, %r9d
je 0x742d
cmpl $0xa, %r9d
je 0x742d
cmpb $0x2a, %r9b
jne 0x7420
cmpb $0x2f, -0x1(%rdx)
je 0x7439
incq %rdx
incq %rcx
testb %r9b, %r9b
jne 0x7403
jmp 0x747f
incq %rdi
movq %rdi, 0x98(%r14)
jmp 0x73fc
addq %rax, %rsi
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x76ea
movq %rbx, %rdi
movq %r14, %rsi
movl $0x47, %edx
movq %r15, %rcx
callq 0x7670
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x748c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x748c
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6f9c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x74b5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::handleCommentSingle()
Token handleCommentSingle () {
        size_t now = _position + 2;

        while (true) {
          char n = _input[now];

          if (n == '\r' || n == '\n' || n == '\0') {
            return makeToken(TOKEN_COMMENT_SINGLE, until(now));
          }
          else {
            ++now;
          }
        }
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rsi), %r13
addq $0x2, %r13
leaq 0x18(%rsp), %rbp
movl $0x2401, %ecx           # imm = 0x2401
leaq 0x8(%rsp), %r15
movq 0x80(%r14), %rsi
movzbl (%rsi,%r13), %r12d
cmpl $0xd, %r12d
ja 0x754d
btl %r12d, %ecx
jae 0x754d
leaq (%rsi,%r13), %rdx
addq 0x90(%r14), %rsi
movq %rbp, 0x8(%rsp)
movq %r15, %rdi
callq 0x76ea
movq %rbx, %rdi
movq %r14, %rsi
movl $0x46, %edx
movq %r15, %rcx
callq 0x7670
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7546
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl $0x2401, %ecx           # imm = 0x2401
jmp 0x7550
incq %r13
cmpl $0xd, %r12d
ja 0x74ec
btl %r12d, %ecx
jae 0x74ec
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7588
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::handleRegex()
Token handleRegex () {
        size_t now = _position + 1;
       /* 
    if (!/^[\\\/]{2}[^\\\/]/.test(paths[0])) {
328         joined = joined.replace(/^[\\\/]{2,}/, '\\');
329       }
330 
*/

        while (true) {
          char n = _input[now];
          if (n == '\\') {
            ++now;
          }
          else if (n == '/') {
            ++now;
            break;
          }
          else if (n == '\0') {
            return makeToken(TOKEN_UNKNOWN);
          }
          ++now;
        }

        char n = _input[now];
        // modifier
        while (n >= 'a' && n <= 'z') {
          n = _input[++now];
        }

        //std::cout << "found regex " << std::string(_input + _position, now - _position) << std::endl;
        return makeToken(TOKEN_REGEX, until(now));
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rsi), %rsi
movq 0x90(%r14), %rax
movq %rax, %rdi
movq %rdi, %rcx
movzbl 0x1(%rsi,%rdi), %edx
cmpl $0x5c, %edx
je 0x75ce
testl %edx, %edx
je 0x7632
leaq 0x1(%rcx), %rdi
cmpl $0x2f, %edx
jne 0x75b2
jmp 0x75d7
addq $0x2, %rcx
movq %rcx, %rdi
jmp 0x75b2
leaq (%rsi,%rcx), %rdx
incq %rdx
movb 0x1(%rdx), %cl
incq %rdx
addb $-0x61, %cl
cmpb $0x1a, %cl
jb 0x75de
addq %rax, %rsi
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x76ea
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4, %edx
movq %r15, %rcx
callq 0x7670
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x763f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x763f
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6f9c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7668
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/quiath[P]fast-atoi/main.cpp
// Function: atoisimple(char const*)
myint atoisimple(const char *b)
{
    myint res = 0; // Initialize result
    int sgn = 1;

    // Skip whitespace
    for (; isspace_fast(*b); ++b);

    if (*b == '-')
    {
        sgn = -1;
        ++b;
    } 
    else if (*b == '+')
    {
        ++b;
    }

    // Iterate through all characters of input string and update result
    for (; *b != 0; ++b)
    {
        if (*b < '0' || *b > '9')  
        {
            return sgn * res;
        }
        res = res * 10 + *b - '0';
    }

    // return result.
    return sgn * res;
}

// Assembly:
movzbl (%rdi), %eax
leal -0x9(%rax), %ecx
cmpl $0x5, %ecx
jae 0x247c
incq %rdi
jmp 0x246c
cmpl $0x20, %eax
je 0x2477
cmpl $0x2b, %eax
je 0x2497
cmpl $0x2d, %eax
jne 0x249a
incq %rdi
movq $-0x1, %rcx
jmp 0x249f
incq %rdi
movl $0x1, %ecx
movb (%rdi), %dl
leal -0x3a(%rdx), %eax
cmpb $-0xa, %al
jae 0x24ac
xorl %eax, %eax
jmp 0x24cb
incq %rdi
xorl %eax, %eax
leaq (%rax,%rax,4), %rax
movzbl %dl, %edx
leaq -0x30(%rdx,%rax,2), %rax
movb (%rdi), %dl
incq %rdi
leal -0x3a(%rdx), %esi
cmpb $-0xb, %sil
ja 0x24b1
imulq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/quiath[P]fast-atoi/main.cpp
// Function: fastatoi(char const*)
myint fastatoi(const char *b)
{
    myint res = 0; // Initialize result
    int sgn = 1;

    // Skip whitespace
    for (; isspace_fast(*b); ++b);

    if (*b == '-')
    {
        sgn = -1;
        ++b;
    } 
    else if (*b == '+')
    {
        ++b;
    }

    // Iterate through all characters of input string and update result
    for (; *b != 0; ++b)
    {
        unsigned d = static_cast<unsigned>(*b) - '0';
        if (d > 9) 
        {
            return sgn * res;
        }
        res = res * 10 + d;
    }

    // return result.
    return sgn * res;
}

// Assembly:
incq %rdi
movb -0x1(%rdi), %dl
movzbl %dl, %eax
leal -0x9(%rax), %ecx
cmpl $0x5, %ecx
jb 0x24d0
cmpl $0x20, %eax
je 0x24d0
cmpl $0x2b, %eax
je 0x24f9
cmpl $0x2d, %eax
jne 0x2502
movq $-0x1, %rcx
jmp 0x24fe
movl $0x1, %ecx
movb (%rdi), %dl
jmp 0x250a
decq %rdi
movl $0x1, %ecx
testb %dl, %dl
je 0x2533
incq %rdi
xorl %eax, %eax
movsbl %dl, %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x2535
leaq (%rax,%rax,4), %rax
movl %edx, %edx
leaq (%rdx,%rax,2), %rax
movb (%rdi), %dl
incq %rdi
testb %dl, %dl
jne 0x2513
jmp 0x2535
xorl %eax, %eax
imulq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/quiath[P]fast-atoi/main.cpp
// Function: fastatoiadd(char const*)
myint fastatoiadd(const char *b)
{
    myint res = 0; // Initialize result

    // Skip whitespace
    for (; isspace_fast(*b); ++b);

    if (*b == '-')
    {
        ++b;
        // Iterate through all characters of input string and update result
        for (; ; ++b)
        {
            unsigned d = static_cast<unsigned>(*b) - '0';
            if (d > 9) 
            {
                return res;
            }
            res = res * 10 - d;
        }

    } 
    else if (*b == '+')
    {
        ++b;
    }
    
    // Iterate through all characters of input string and update result
    for (; ; ++b)
    {
        unsigned d = static_cast<unsigned>(*b) - '0';
        if (d > 9) 
        {
            return res;
        }
        res = res * 10 + d;
    }

    //  unreachable
    return res;
}

// Assembly:
incq %rdi
movb -0x1(%rdi), %al
movzbl %al, %ecx
leal -0x9(%rcx), %edx
cmpl $0x5, %edx
jb 0x253a
cmpl $0x20, %ecx
je 0x253a
cmpl $0x2b, %ecx
je 0x2579
cmpl $0x2d, %ecx
jne 0x257d
xorl %ecx, %ecx
movsbl (%rdi), %edx
movq %rcx, %rax
addq %rcx, %rcx
incq %rdi
leaq (%rcx,%rcx,4), %rcx
addl $-0x30, %edx
subq %rdx, %rcx
cmpl $0xa, %edx
jb 0x255c
jmp 0x25a8
movb (%rdi), %al
jmp 0x2580
decq %rdi
movsbl %al, %ecx
addl $-0x30, %ecx
cmpl $0x9, %ecx
ja 0x25a9
incq %rdi
xorl %eax, %eax
leaq (%rax,%rax,4), %rax
movl %ecx, %ecx
leaq (%rcx,%rax,2), %rax
movsbl (%rdi), %ecx
incq %rdi
addl $-0x30, %ecx
cmpl $0xa, %ecx
jb 0x2590
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/SilentAssassinMa[P]Sudoku-Solver/main.cpp
// Function: main
int main(int argc, char **argv)
{
    if (argc != 2)
    {
        std::cout << " Usage : " << argv[0] << " inputfilename" << std::endl;
        return 0;
    }

    clock_t time_start = clock();
    SudokuSolver solver1(argv[1]);
    SudokuSolver solver2(argv[1]);
    solver1.BackTracking();
    solver2.SimulatedAnnealing(0.1, 1e9);
    clock_t time_end = clock();
    std::cout << "Time use : " << double(time_end - time_start) / CLOCKS_PER_SEC << "s" << std::endl;

    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x638, %rsp            # imm = 0x638
movq %rsi, %r14
cmpl $0x2, %edi
jne 0x24db
callq 0x20f0
movq %rax, %rbx
movq 0x8(%r14), %rsi
leaq 0x320(%rsp), %rdi
callq 0x25a4
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x25a4
leaq 0x320(%rsp), %rdi
callq 0x27cc
leaq 0x8(%rsp), %rdi
movsd 0x1bd5(%rip), %xmm0     # 0x4008
movl $0x3b9aca00, %esi       # imm = 0x3B9ACA00
callq 0x2d58
callq 0x20f0
movq %rax, %r14
movq 0x3b8c(%rip), %rdi      # 0x5fd8
leaq 0x1bde(%rip), %rsi      # 0x4031
movl $0xb, %edx
callq 0x2190
subq %rbx, %r14
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
divsd 0x1ba0(%rip), %xmm0     # 0x4010
movq 0x3b61(%rip), %rdi      # 0x5fd8
callq 0x21d0
movq %rax, %rbx
leaq 0x1bb7(%rip), %rsi      # 0x403d
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x8(%rsp), %rdi
callq 0x277c
leaq 0x320(%rsp), %rdi
callq 0x277c
movl $0x1, %eax
jmp 0x256e
movq 0x3af6(%rip), %rbx      # 0x5fd8
leaq 0x1b2f(%rip), %rsi      # 0x4018
movl $0x9, %edx
movq %rbx, %rdi
callq 0x2190
movq (%r14), %r14
testq %r14, %r14
je 0x251a
movq %r14, %rdi
callq 0x20a0
movq 0x3acb(%rip), %rdi      # 0x5fd8
movq %r14, %rsi
movq %rax, %rdx
callq 0x2190
jmp 0x2531
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2200
leaq 0x1aea(%rip), %rsi      # 0x4022
movl $0xe, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
xorl %eax, %eax
addq $0x638, %rsp            # imm = 0x638
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x258d
jmp 0x2580
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x277c
leaq 0x320(%rsp), %rdi
callq 0x277c
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/SilentAssassinMa[P]Sudoku-Solver/SudokuSolver.cpp
// Function: SudokuSolver::PrintSudoku(int*)
void SudokuSolver::PrintSudoku(int *sudoku)
{
    for (int i = 1; i <= 9; i++)
    {
        if (i % 3 == 1)
        {
            cout << "+-----+-----+-----+" << endl;
        }
        cout << "|";
        for (int j = 1; j <= 9; j++)
        {
            if (j % 3 == 0)
            {
                cout << FindElement(sudoku, i, j) << "|";
            }
            else
            {
                cout << FindElement(sudoku, i, j) << " ";
            }
        }
        cout << endl;
    }
    cout << "+-----+-----+-----+" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl $0x1, %eax
movq 0x2872(%rip), %r12      # 0x5fd8
leaq 0xa04(%rip), %r15       # 0x4171
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
movq %rax, (%rsp)
imull $-0x55, %eax, %eax
addb $0x55, %al
cmpb $0x54, %al
ja 0x37c0
movl $0x13, %edx
movq %r12, %rdi
leaq 0x9ca(%rip), %rsi       # 0x415d
callq 0x2190
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movl $0x1, %r13d
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2190
xorl %r15d, %r15d
movq %r13, %rax
mulq %rbp
shrl %edx
leal (%rdx,%rdx,2), %eax
decb %al
cmpb %r15b, %al
movq %rbp, %rbx
leaq 0x82d(%rip), %rbp       # 0x4020
leaq 0x977(%rip), %rax       # 0x4171
cmoveq %rax, %rbp
movl (%r14,%r15,4), %esi
movq %r12, %rdi
callq 0x2210
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
movq %rbx, %rbp
callq 0x2190
incq %r13
incq %r15
cmpq $0x9, %r15
jne 0x37d9
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq (%rsp), %rax
incq %rax
addq $0x24, %r14
cmpq $0xa, %rax
leaq 0x90a(%rip), %r15       # 0x4171
jne 0x3777
leaq 0x8e9(%rip), %rsi       # 0x415d
movl $0x13, %edx
movq %r12, %rdi
callq 0x2190
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/main.cpp
// Function: getMultispampleXVisual(_XDisplay*, int)
XVisualInfo * getMultispampleXVisual (Display *dpy, int screen)
{
    XVisualInfo *vi = NULL;

    int attribs [ 100 ] ;
    memcpy( attribs, Visual_attribs, sizeof( Visual_attribs ) );

    GLXFBConfig fbconfig = 0;
    int         fbcount;
    GLXFBConfig *fbc = glXChooseFBConfig( dpy, screen, attribs, &fbcount );
    if ( fbc )
    {
        if ( fbcount >= 1 )
            fbconfig = fbc[0];
        XFree( fbc );
    }

    if ( !fbconfig )
    {
        fprintf(stderr, "Failed to get MSAA GLXFBConfig\n" );
        return NULL;
    }  
    
    vi = glXGetVisualFromFBConfig( dpy, fbconfig );

    return vi;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %esi, %eax
movq %rdi, %rbx
leaq 0x57ce(%rip), %rsi      # 0x9010
leaq 0x10(%rsp), %rdx
movl $0xd, %ecx
movq %rdx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl $0x0, 0x68(%rdx)
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
movl %eax, %esi
callq 0x3440
testq %rax, %rax
je 0x38a2
cmpl $0x0, 0xc(%rsp)
jle 0x389a
movq (%rax), %r14
movq %rax, %rdi
callq 0x33d0
testq %r14, %r14
je 0x38a2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3480
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x33d0
callq 0x3660
xorl %eax, %eax
jmp 0x388f
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/infra.cpp
// Function: closeLog()
void closeLog ()
{
#ifndef _DEBUG
   if (log1)
   {
      fputs ("Closing log\n", log1);
      fclose (log1);
      log1 = 0;
   }
#endif
}

// Assembly:
movq 0x82d4(%rip), %rsi      # 0xc4a8
testq %rsi, %rsi
je 0x4201
pushq %rax
leaq 0x51bb(%rip), %rdi      # 0x939c
callq 0x3340
movq 0x82bb(%rip), %rdi      # 0xc4a8
callq 0x32d0
movq $0x0, 0x82ab(%rip) # 0xc4a8
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/infra.cpp
// Function: setFrameSizeForGL(int, int)
void setFrameSizeForGL (int width, int height)
{    
    screen_height = height;
    screen_width = width;
	
	// Reshape
	glViewport( 0, 0, width, height );
	glMatrixMode( GL_PROJECTION );
	glLoadIdentity();
	
    gluPerspective( 45.0f, (float)width / (float)height, 0.1f, 100.0f );
    
	glMatrixMode( GL_MODELVIEW );
	glLoadIdentity();	
}

// Assembly:
pushq %rax
movl %esi, %ecx
movl %edi, %edx
cvtsi2ss %esi, %xmm0
cvtsi2ss %edi, %xmm1
divss %xmm0, %xmm1
movss %xmm1, 0x4(%rsp)
xorl %edi, %edi
xorl %esi, %esi
callq 0x30d0
movl $0x1701, %edi           # imm = 0x1701
callq 0x3430
callq 0x33f0
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rsp), %xmm1
movsd 0x4fd6(%rip), %xmm0     # 0x9238
movsd 0x4fd6(%rip), %xmm2     # 0x9240
movsd 0x4fd6(%rip), %xmm3     # 0x9248
callq 0x3380
movl $0x1700, %edi           # imm = 0x1700
callq 0x3430
popq %rax
jmp 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/infra.cpp
// Function: freePoints()
static void freePoints()
{
    if (m3d_pt_count > 0)
    {
        delete[] pointData;
        delete[] corePoints;
        
        corePoints = NULL;
    }
    
    m3d_pt_count = 0;
}

// Assembly:
cmpq $0x0, 0x718f(%rip)      # 0xc4e0
jle 0x5385
pushq %rax
movq 0x7155(%rip), %rdi      # 0xc4b0
testq %rdi, %rdi
je 0x5365
callq 0x33e0
movq 0x714c(%rip), %rdi      # 0xc4b8
testq %rdi, %rdi
je 0x5376
callq 0x33e0
movq $0x0, 0x7137(%rip) # 0xc4b8
addq $0x8, %rsp
movq $0x0, 0x7150(%rip) # 0xc4e0
retq
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/infra.cpp
// Function: GetConfig()
void GetConfig (void)
{
    m3d_pt_count = 0;
    current_set_index = 0;
        
    if (m_Preview == NO)
    {
        current_set_index = -1;
        selectNextImage();
    }
        
    corePoints = NULL;
                                
    srand ((unsigned int)time(NULL));
        
    stdAlpha = AppParams::getTransparency();
        
    rotationSpeed = AppParams::getRotationSpeed() * 0.01f;
        
    detailLevel = AppParams::getDetailValue();
        
    lightOption = AppParams::getLightSource();
        
    paletteOption = AppParams::getPalette();
        
    USE_LIGHT = AppParams::getLightMoving();
        
    rolloverPeriod = AppParams::getIntervalInSecs();
}

// Assembly:
pushq %rax
movq $0x0, 0x6ed0(%rip) # 0xc4e0
movl $0x0, 0x6ee2(%rip)      # 0xc4fc
cmpb $0x0, 0x6e9f(%rip)      # 0xc4c0
jne 0x5632
movl $0xffffffff, 0x6ecf(%rip) # imm = 0xFFFFFFFF
callq 0x546b
movq $0x0, 0x6e7b(%rip) # 0xc4b8
xorl %edi, %edi
callq 0x3290
movl %eax, %edi
callq 0x32b0
callq 0x7e68
movss %xmm0, 0x6e98(%rip)     # 0xc4f0
callq 0x7ec4
mulss 0x3ccb(%rip), %xmm0     # 0x9330
movss %xmm0, 0x6e87(%rip)     # 0xc4f4
callq 0x7f42
movss %xmm0, 0x6e7e(%rip)     # 0xc4f8
callq 0x7fa2
callq 0x8080
callq 0x80d4
movb %al, 0x6e41(%rip)       # 0xc4d0
callq 0x813e
cvttss2si %xmm0, %rax
movq %rax, 0x6e60(%rip)      # 0xc500
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::GetExactColor(int, int)
DWORD M3DDrawer::GetExactColor (int cnt, int fraction)
{
	long color;
    
	if (cnt > 0 && cnt < 256)
    {
        cnt = fraction + ((cnt - 1) << 4) ;
        color = (cnt & 255) ;
        cnt = cnt >> 4;
    }
    else
        color = (cnt & 15) << 4 ;
    
    color += ((cnt & 48) << 10);
    
    color += ((cnt & 192) << 16);
    
    return alternate_palette ? TransformColor (color, pal_case) : color;
}

// Assembly:
leal -0x1(%rsi), %ecx
movl %esi, %eax
shll $0x4, %eax
cmpl $0xfe, %ecx
ja 0x5e5f
leal (%rax,%rdx), %esi
addl $-0x10, %esi
movzbl %sil, %eax
sarl $0x4, %esi
jmp 0x5e64
andl $0xf0, %eax
movl %esi, %ecx
andl $0x30, %ecx
shll $0xa, %ecx
orl %eax, %ecx
shll $0x10, %esi
andl $0xc00000, %esi         # imm = 0xC00000
orl %ecx, %esi
cmpb $0x1, 0x68(%rdi)
jne 0x5e8c
movl 0x6c(%rdi), %eax
movq %rsi, %rdi
movl %eax, %esi
jmp 0x5e90
movq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::TransformColor(long, int)
long M3DDrawer::TransformColor (long color, int pal_case)
{
	int red, green, blue;

	red = color & 0xff;
	green = (color >> 8) & 0xff;
	blue = (color >> 16) & 0xff;
 
	if (((blue>>6) > 0) && ((blue >> 6) < 4) && green==0)
    {
		green = red >> 2;
        
		if (pal_case == 0)
        {
			blue -= (63 - (red >> 2));
        }
		else if (pal_case == 1)
        {
			if ((blue >> 6) == 3)
				blue -= (63 - (red >> 2));
			else if ((blue >> 6) == 1)
				blue += (63 - (red >> 2));
        }
		else if (pal_case == 2)
        {
			if ((blue >> 6) == 3)
				blue += (63 - (red >> 2));
			else if ((blue >> 6) == 1)
				blue -= (63 - (red >> 2));
        }
        
		red = 0;
		
		color = red + (blue << 16) + (green << 8);
		//green += (red >> 1);
    } 
    
	return color;
}

// Assembly:
movq %rdi, %rax
movl %eax, %ecx
shrl $0x10, %ecx
movzbl %cl, %ecx
cmpl $0x40, %ecx
setb %dl
testl $0xff00, %eax           # imm = 0xFF00
setne %dil
orb %dl, %dil
jne 0x5ef8
movl %ecx, %edx
shrl $0x6, %edx
shrl $0x2, %eax
andl $0x3f, %eax
cmpl $0x2, %esi
je 0x5ed6
cmpl $0x1, %esi
je 0x5eca
testl %esi, %esi
je 0x5ee9
jmp 0x5ef0
cmpl $0x1, %edx
je 0x5ee0
cmpl $0x3, %edx
je 0x5ee9
jmp 0x5ef0
cmpl $0x1, %edx
je 0x5ee9
cmpl $0x3, %edx
jne 0x5ef0
movl %eax, %edx
xorl $0x3f, %edx
addl %edx, %ecx
jmp 0x5ef0
movl %eax, %edx
xorl $0x3f, %edx
subl %edx, %ecx
shll $0x10, %ecx
shll $0x8, %eax
orl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::Julia(long double, long double, long double, long double, int&, int&)
DWORD M3DDrawer::Julia(long double juliaRe, long double juliaIm,
			long double Re, long double Im, int &mandel, int &fraction)
{
    int cnt=0;
    long double cRe, cIm, tRe, tIm;
    long double cRe2, cIm2, last=0, final;
    
    cRe = Re, cIm = Im;
    do {
        cRe2 = cRe * cRe;
        cIm2 = cIm * cIm;
        final = cRe2 + cIm2;
        
        if ((final <= 4.0) && cnt < 256)
		{
            last = final;
            tRe = cRe2 - cIm2;
            tIm = 2 * cRe * cIm;
            cRe = tRe + juliaRe, cIm = tIm + juliaIm;
            cnt++;
		}
        else break;
    } while (1);
    
    long color=0;
    
    fraction = 0;
    mandel = cnt;
    
    if (cnt > 0 && cnt < 256)
    {
        fraction = 16 * (4.0 - last)/(final - last) ;
    }
    
    color = GetExactColor (cnt, fraction);
    
    return color;   
}

// Assembly:
fldt 0x38(%rsp)
fldt 0x28(%rsp)
fldt 0x18(%rsp)
fstpt -0xc(%rsp)
fld %st(0)
fmul %st(1), %st
fld %st(2)
fmul %st(3), %st
fld %st(0)
fadd %st(2), %st
flds 0x34e0(%rip)            # 0x93fc
fucompi %st(1), %st
fldt 0x8(%rsp)
fstpt -0x18(%rsp)
jae 0x5f44
fstp %st(4)
fstp %st(2)
fstp %st(2)
fstp %st(1)
fstp %st(0)
xorl %r8d, %r8d
movl %r8d, (%rdx)
movl %r8d, (%rsi)
fldz
fldz
jmp 0x5ff4
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
flds 0x34ad(%rip)            # 0x93fc
fldz
fstp %st(0)
incl %ecx
fxch %st(3)
fsubp %st, %st(2)
fxch %st(3)
fadd %st, %st(0)
fmulp %st, %st(4)
fldt -0x18(%rsp)
faddp %st, %st(1)
fldt -0xc(%rsp)
faddp %st, %st(4)
fld %st(0)
fmul %st(1), %st
fld %st(4)
fmul %st(5), %st
fld %st(0)
fadd %st(2), %st
fxch %st(4)
fucomi %st(4), %st
fxch %st(3)
fxch %st(5)
fxch %st(2)
fxch %st(4)
fxch %st(1)
fxch %st(3)
fxch %st(1)
fxch %st(2)
jb 0x5f95
cmpl $0xff, %ecx
jb 0x5f51
fstp %st(6)
fstp %st(4)
fstp %st(3)
fstp %st(1)
fstp %st(0)
movl $0x0, (%rdx)
leal 0x1(%rcx), %eax
movl %eax, (%rsi)
movl $0x100, %r8d            # imm = 0x100
cmpl $0xff, %ecx
jae 0x5ff4
fld %st(1)
fsubrs 0x343c(%rip)            # 0x93fc
fmuls 0x343a(%rip)            # 0x9400
fxch %st(1)
fsubp %st, %st(2)
fdivp %st, %st(1)
fnstcw -0x20(%rsp)
movzwl -0x20(%rsp), %ecx
orl $0xc00, %ecx            # imm = 0xC00
movw %cx, -0x1e(%rsp)
fldcw -0x1e(%rsp)
fistpl -0x1c(%rsp)
fldcw -0x20(%rsp)
movl -0x1c(%rsp), %ecx
movl %ecx, (%rdx)
jmp 0x5ffd
fstp %st(1)
fstp %st(0)
movl (%rdx), %ecx
movl %r8d, %eax
movl %eax, %esi
movl %ecx, %edx
jmp 0x5e40
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::Strange(long double, long double, int&, int&)
DWORD M3DDrawer::Strange(long double Re, long double Im, int &mandel, int &fraction)
{
    int cnt=0;
    long double cRe, cIm, tRe, tIm;
    long double cRe2, cIm2, last=0, final;
    
    cRe = Re, cIm = Im;
    do {
        cRe2 = cRe * cRe;
        cIm2 = cIm * cIm;
        final = cRe2 + cIm2;
        
#ifdef DEMO_VERSION
		if ((final <= 4.0) && cnt < 256)
#else
            if ((final <= 4.0) && cnt < 256)
#endif
            {
                last = final;
                tRe = cRe2 - cIm2;
                tIm = 2 * cRe * cIm;
                cRe = tRe + Re, cIm = tIm + Im;
                cnt++;
            }
            else break;
    } while (1);
    
    long color = 0;
    
    fraction = 0;
    mandel = cnt;
    
    if (cnt > 0 && cnt < 256)
    {
        fraction = 16 * (4.0 - last)/(final - last) ;
    }
    color = GetExactColor (cnt, fraction);
    
    return color;   
}

// Assembly:
fldt 0x18(%rsp)
fldt 0x8(%rsp)
fld %st(0)
fmul %st(1), %st
fld %st(2)
fmul %st(3), %st
fld %st(0)
fadd %st(2), %st
flds 0x33dc(%rip)            # 0x93fc
fucompi %st(1), %st
jae 0x603e
fstp %st(4)
fstp %st(3)
fstp %st(0)
fstp %st(1)
fstp %st(0)
xorl %r8d, %r8d
movl %r8d, (%rdx)
movl %r8d, (%rsi)
fldz
jmp 0x60f8
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
fld %st(3)
fld %st(5)
fld %st(5)
fstpt -0xc(%rsp)
fxch %st(2)
fstpt -0x18(%rsp)
incl %ecx
fxch %st(3)
fsubp %st, %st(2)
fxch %st(2)
fadd %st, %st(0)
fmulp %st, %st(2)
faddp %st, %st(2)
fadd %st(2), %st
fld %st(1)
fmul %st(2), %st
fld %st(1)
fmul %st(2), %st
fld %st(0)
fadd %st(2), %st
flds 0x3387(%rip)            # 0x93fc
fucompi %st(1), %st
fldt -0xc(%rsp)
fxch %st(5)
fxch %st(3)
fxch %st(4)
fxch %st(2)
fxch %st(3)
fxch %st(1)
fxch %st(2)
jb 0x6093
cmpl $0xff, %ecx
jb 0x604d
fstp %st(0)
fstp %st(5)
fstp %st(2)
fstp %st(0)
fstp %st(1)
fstp %st(1)
movl $0x0, (%rdx)
leal 0x1(%rcx), %eax
movl %eax, (%rsi)
movl $0x100, %r8d            # imm = 0x100
cmpl $0xff, %ecx
jae 0x60f8
fldt -0x18(%rsp)
fld %st(0)
fsubrs 0x3338(%rip)            # 0x93fc
fmuls 0x3336(%rip)            # 0x9400
fxch %st(2)
fsubp %st, %st(1)
fdivrp %st, %st(1)
fnstcw -0x20(%rsp)
movzwl -0x20(%rsp), %ecx
orl $0xc00, %ecx            # imm = 0xC00
movw %cx, -0x1e(%rsp)
fldcw -0x1e(%rsp)
fistpl -0x1c(%rsp)
fldcw -0x20(%rsp)
movl -0x1c(%rsp), %ecx
movl %ecx, (%rdx)
jmp 0x60ff
fstp %st(0)
movl (%rdx), %ecx
movl %r8d, %eax
movl %eax, %esi
movl %ecx, %edx
jmp 0x5e40
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::GetParamsByIndex(int, DrawParams&, ShapeParams&)
bool M3DDrawer::GetParamsByIndex (int index, struct DrawParams &dp, struct ShapeParams &sp)
{
    index = (index % PRESET_COUNT);
    
    memcpy (&dp, &rotationArray[index], sizeof (struct DrawParams));
    memcpy (&sp, &spArray[index], sizeof (struct ShapeParams));
    
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %rax
movq %rdi, %r14
movslq %esi, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x21, %rdx
addl %esi, %edx
leal (%rdx,%rdx,4), %edx
subl %edx, %ecx
movslq %ecx, %r15
imulq $0xd0, %r15, %rsi
addq 0x48(%rdi), %rsi
movl $0xd0, %edx
movq %rax, %rdi
callq 0x3270
imulq $0x70, %r15, %rsi
addq 0x50(%r14), %rsi
movl $0xe, %ecx
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::Paint(int, bool, pointData**, corePointData**)
bool M3DDrawer::Paint (int set_index, bool preview, struct pointData ** pointData,
                      struct corePointData ** corePoints)
{
    bool ret = false;

	if (preview)
    {
		struct DrawParams previewDraw;
		struct ShapeParams previewShape;
        
		memcpy (&previewDraw, &defParams, sizeof (struct DrawParams));
		memcpy (&previewShape, &defShapeParams, sizeof (struct ShapeParams));
        
        GetParamsByIndex (set_index, previewDraw, previewShape);
                
		ret = ShowInPreviewWindow (&previewShape, &previewDraw, pointData, corePoints);
    }
	  else
    {
		// draw_zpr (hdc, &currentShape, &currentParams);
    }

  return (ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movl %edx, %ebx
testl %edx, %edx
je 0x6647
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r12
movslq %esi, %rax
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movslq %eax, %rbp
imulq $0xd0, %rbp, %rsi
addq 0x48(%rdi), %rsi
leaq 0x70(%rsp), %r13
movl $0xd0, %edx
movq %r13, %rdi
callq 0x3270
imulq $0x70, %rbp, %rsi
addq 0x50(%r12), %rsi
movq %rsp, %rax
movl $0xe, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r12, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x665c
movl %ebx, %eax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::GetMandelColor(DrawParams&, ShapeParams&, long double, long double, int&, int&)
long M3DDrawer::GetMandelColor (struct DrawParams &params, struct ShapeParams &sp,
								long double alpha, long double alp, int &mandel, int &fraction)
{
	long double xCenter = params.xCenter,
    			yCenter = params.yCenter, 
    			xRadius = params.xRadius;
    
	long color = 0;
	long double Re, Im;
    
	double power = POWER_ADD + POWER_RANGE * (alpha/sp.alpha_range);
        
	Re = xRadius * cos (alp + params.sampleRotation);
	Im = xRadius * sin (alp + params.sampleRotation);
    
	double k = pow (POWER_BASE, power * params.stretchRatio);
    
	Re = Re / k;
	Im = Im / k;
    
	Re += xCenter;
	Im += yCenter;
    
	if (params.juliaSet)
    {
		color = Julia(params.juliaRe, params.juliaIm, Re, Im, mandel, fraction);
    }
	else
    {
		color = Strange(Re, Im, mandel, fraction);
    }
    
	return color;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
fldt 0xd0(%rsp)
fld %st(0)
fstpt 0x68(%rsp)
fldt 0xc0(%rsp)
fldt 0x50(%rsi)
fstpt 0x80(%rsp)
fldt 0x60(%rsi)
fstpt 0x8c(%rsp)
fdivl 0x18(%rdx)
fldt 0x70(%rsi)
fstpt 0x4c(%rsp)
fmuls 0x2146(%rip)            # 0x9410
fldz
faddp %st, %st(1)
fstpl 0x60(%rsp)
fadds 0x34(%rsi)
fstpt (%rsp)
callq 0x3390
fldt 0x4c(%rsp)
fmulp %st, %st(1)
fstpt 0x74(%rsp)
fldt 0x68(%rsp)
fadds 0x34(%r12)
fstpt (%rsp)
callq 0x3500
fldt 0x4c(%rsp)
fmulp %st, %st(1)
fstpt 0x4c(%rsp)
cvtss2sd 0x30(%r12), %xmm1
mulsd 0x60(%rsp), %xmm1
movsd 0x21b9(%rip), %xmm0     # 0x94d0
callq 0x3590
movsd %xmm0, 0x58(%rsp)
fldl 0x58(%rsp)
fldt 0x74(%rsp)
fdiv %st(1), %st
fldt 0x80(%rsp)
faddp %st, %st(1)
fldt 0x4c(%rsp)
fdivp %st, %st(2)
fldt 0x8c(%rsp)
faddp %st, %st(2)
cmpb $0x1, (%r12)
jne 0x737a
fldt 0x10(%r12)
fldt 0x20(%r12)
fxch %st(3)
fstpt 0x30(%rsp)
fxch %st(1)
fstpt 0x20(%rsp)
fxch %st(1)
fstpt 0x10(%rsp)
fstpt (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5efa
jmp 0x7391
fxch %st(1)
fstpt 0x10(%rsp)
fstpt (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6006
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::GetPixelCoordinates(double, double, double, long double, long double, long double, double, double&, double&, double&, double&, double&, double&)
void M3DDrawer::GetPixelCoordinates (double y1, double r, double l, long double alpha, long double beta,
                                     long double coef, double slope,
                                     double & x_real, double & y_real, double & z_real,
                                     double & x_norm, double & y_norm, double & z_norm)
{
	double temp_x ;
    
	x_real = r * cos (alpha);
	y_real = y1 ;
	z_real = r * sin (alpha);
    
	// initial values (assuming l=1)
	// x_norm = cos (coef*alp);
	// y_norm = sin (coef*alp);
    
    x_norm = cos (beta);
    y_norm = sin (beta);
    
	z_norm = 0;
    
	// first, slope (around x=0)
	z_norm = -y_norm * sin (slope);
	y_norm = y_norm * cos (slope); // ignoring z it's 0 anyway
    
	// turn by alpha (around y=0)
    
	temp_x = x_norm;
	x_norm = x_norm * cos(alpha) - z_norm * sin (alpha);
	//y_norm = y_norm;
	z_norm = temp_x * sin (alpha) + z_norm * cos (alpha);
    
	// add to centerpoints
	x_real += x_norm * l;
	y_real += y_norm * l;
	z_real += z_norm * l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r15
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movsd %xmm3, 0x38(%rsp)
movsd %xmm2, 0x58(%rsp)
movsd %xmm0, 0x50(%rsp)
movq 0xd0(%rsp), %rbp
fldt 0xb0(%rsp)
fstpt 0x20(%rsp)
fldt 0xa0(%rsp)
fld %st(0)
fstpt 0x44(%rsp)
movsd %xmm1, 0x60(%rsp)
fldl 0x60(%rsp)
fstpt 0x14(%rsp)
fstpt (%rsp)
callq 0x3390
fldt 0x14(%rsp)
fmulp %st, %st(1)
fstpl (%r12)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, (%r14)
fldt 0x44(%rsp)
fstpt (%rsp)
callq 0x3500
fldt 0x14(%rsp)
fmulp %st, %st(1)
fstpl (%rbx)
fldt 0x20(%rsp)
fstpt (%rsp)
callq 0x3390
fstpl (%r13)
fldt 0x20(%rsp)
fstpt (%rsp)
callq 0x3500
fstpl (%r15)
movq $0x0, (%rbp)
movsd (%r15), %xmm0
xorps 0x1b47(%rip), %xmm0     # 0x9560
movaps %xmm0, 0x20(%rsp)
movsd 0x38(%rsp), %xmm0
callq 0x3080
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rbp)
movsd (%r15), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x38(%rsp), %xmm0
callq 0x3600
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, (%r15)
fldl (%r13)
fstpt 0x38(%rsp)
fldt 0x44(%rsp)
fstpt (%rsp)
callq 0x3390
fstpt 0x20(%rsp)
fldl (%rbp)
fstpt 0x14(%rsp)
fldt 0x44(%rsp)
fstpt (%rsp)
callq 0x3500
fldt 0x14(%rsp)
fmulp %st, %st(1)
fldt 0x38(%rsp)
fldt 0x20(%rsp)
fmulp %st, %st(1)
fsubp %st, %st(1)
fstpl (%r13)
fldt 0x44(%rsp)
fstpt (%rsp)
callq 0x3500
fstpt 0x20(%rsp)
fldl (%rbp)
fstpt 0x14(%rsp)
fldt 0x44(%rsp)
fstpt (%rsp)
callq 0x3390
fldt 0x14(%rsp)
fmulp %st, %st(1)
fldt 0x38(%rsp)
fldt 0x20(%rsp)
fmulp %st, %st(1)
faddp %st, %st(1)
fstpl (%rbp)
movsd (%r13), %xmm0
movsd 0x58(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd (%r12), %xmm0
movsd %xmm0, (%r12)
movsd (%r15), %xmm0
mulsd %xmm1, %xmm0
addsd (%r14), %xmm0
movsd %xmm0, (%r14)
mulsd (%rbp), %xmm1
addsd (%rbx), %xmm1
movsd %xmm1, (%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::resetToDefaults()
void AppParams::resetToDefaults()
{
   UserDefaults::sharedInstance()->deleteKey (kIntervalOption);
   UserDefaults::sharedInstance()->deleteKey (kRotationSpeed);
   UserDefaults::sharedInstance()->deleteKey (kDetailLevel);
   UserDefaults::sharedInstance()->deleteKey (kShuffleImages);
   UserDefaults::sharedInstance()->deleteKey (kTransparencyLevel);
   UserDefaults::sharedInstance()->deleteKey (kPaletteType);
   UserDefaults::sharedInstance()->deleteKey (kLightSource);
   UserDefaults::sharedInstance()->deleteKey (kGlossyOption);
   UserDefaults::sharedInstance()->deleteKey (kGlossRandom);

   UserDefaults::sharedInstance()->deleteKey (kLightDistance);
   UserDefaults::sharedInstance()->deleteKey (kLight2Sides);

   for (int i=0; i < PRESET_COUNT; i++)
   {
      char *key = getImageKey (i);
      UserDefaults::sharedInstance()->deleteKey (key);
   }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x82e2
leaq 0x18eb(%rip), %rsi      # 0x95f1
movq %rax, %rdi
callq 0x8328
callq 0x82e2
leaq 0x18e7(%rip), %rsi      # 0x9601
movq %rax, %rdi
callq 0x8328
callq 0x82e2
leaq 0x18e2(%rip), %rsi      # 0x9610
movq %rax, %rdi
callq 0x8328
callq 0x82e2
leaq 0x18db(%rip), %rsi      # 0x961d
movq %rax, %rdi
callq 0x8328
callq 0x82e2
leaq 0x18d6(%rip), %rsi      # 0x962c
movq %rax, %rdi
callq 0x8328
callq 0x82e2
leaq 0x18cf(%rip), %rsi      # 0x9639
movq %rax, %rdi
callq 0x8328
callq 0x82e2
leaq 0x18c8(%rip), %rsi      # 0x9646
movq %rax, %rdi
callq 0x8328
callq 0x82e2
leaq 0x18c1(%rip), %rsi      # 0x9653
movq %rax, %rdi
callq 0x8328
callq 0x82e2
leaq 0x18b9(%rip), %rsi      # 0x965f
movq %rax, %rdi
callq 0x8328
callq 0x82e2
leaq 0x18b2(%rip), %rsi      # 0x966c
movq %rax, %rdi
callq 0x8328
callq 0x82e2
leaq 0x18ad(%rip), %rsi      # 0x967b
movq %rax, %rdi
callq 0x8328
leaq 0x4883(%rip), %rbx      # 0xc660
leaq 0x1804(%rip), %r14      # 0x95e8
xorl %ebp, %ebp
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3170
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3050
callq 0x82e2
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8328
incl %ebp
cmpl $0x5, %ebp
jne 0x7de6
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::getTransparencyLevel()
int AppParams::getTransparencyLevel ()
{
    int ret = UserDefaults::sharedInstance()->getInteger (kTransparencyLevel, DEF_TRANSPARENCY);
    if (ret < MIN_TRANSP) ret = MIN_TRANSP;
    if (ret > MAX_TRANSP) ret = MAX_TRANSP;

    return ret;
}

// Assembly:
pushq %rax
callq 0x82e2
leaq 0x17e5(%rip), %rsi      # 0x962c
movq %rax, %rdi
movl $0x1, %edx
callq 0x841a
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpl $0xa, %eax
movl $0xa, %ecx
cmovgel %ecx, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::getRotationSpeed()
float AppParams::getRotationSpeed ()
{
    int ret = UserDefaults::sharedInstance()->getInteger (kRotationSpeed, DEF_ROTATION_SPEED);
    if (ret < MIN_SPEED) ret = MIN_SPEED;
    if (ret > MAX_SPEED) ret = MAX_SPEED;
    return (float)ret;
}

// Assembly:
pushq %rax
callq 0x82e2
leaq 0x1730(%rip), %rsi      # 0x9601
movq %rax, %rdi
movl $0x19, %edx
callq 0x841a
cmpl $0xb, %eax
movl $0xa, %ecx
cmovgel %eax, %ecx
cmpl $0x28, %ecx
movl $0x28, %eax
cmovll %ecx, %eax
cvtsi2ss %eax, %xmm0
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/intheswim[P]FractalTubes/AppParams.cpp
// Function: AppParams::getDetailLevel()
int AppParams::getDetailLevel()
{
   int ret = UserDefaults::sharedInstance()->getInteger (kDetailLevel, DEF_DETAIL_LEVEL);
   if (ret < 0) ret = 0;
   if (ret > 4) ret = 4;

   return ret;
}

// Assembly:
pushq %rax
callq 0x82e2
leaq 0x16ef(%rip), %rsi      # 0x9610
movq %rax, %rdi
movl $0x1, %edx
callq 0x841a
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpl $0x4, %eax
movl $0x4, %ecx
cmovgel %ecx, %eax
popq %rcx
retq