LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x90(%rax), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rax
movq 0x80(%rax), %rcx
movq -0x18(%rbp), %rdx
movb (%rcx,%rdx), %cl
movb %cl, -0x19(%rbp)
movq 0x80(%rax), %rax
movq -0x18(%rbp), %rcx
movb 0x1(%rax,%rcx), %al
movb %al, -0x1a(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0xd, %eax
jne 0xef52
movsbl -0x19(%rbp), %eax
cmpl $0xa, %eax
jne 0xef52
movq -0x58(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0xf01c
movsbl -0x19(%rbp), %eax
cmpl $0xd, %eax
je 0xef64
movsbl -0x19(%rbp), %eax
cmpl $0xa, %eax
jne 0xef8b
movq -0x58(%rbp), %rax
movq 0x98(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xf01a
movsbl -0x19(%rbp), %eax
cmpl $0x2a, %eax
jne 0xeff0
movsbl -0x1a(%rbp), %eax
cmpl $0x2f, %eax
jne 0xeff0
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x2, %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xf420
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x70(%rbp), %rcx
movl $0x47, %edx
callq 0xf330
jmp 0xefce
leaq -0x40(%rbp), %rdi
callq 0x3170
jmp 0xf021
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3170
jmp 0xf02b
movsbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0xf00a
movq -0x58(%rbp), %rsi
movq -0x68(%rbp), %rdi
xorl %edx, %edx
callq 0xe720
jmp 0xf021
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xf018
jmp 0xf01a
jmp 0xf01c
jmp 0xeef2
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x90(%rax), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0xd, %eax
je 0xf0a2
movsbl -0x19(%rbp), %eax
cmpl $0xa, %eax
je 0xf0a2
movsbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0xf0f9
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xf420
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x70(%rbp), %rcx
movl $0x46, %edx
callq 0xf330
jmp 0xf0cf
leaq -0x40(%rbp), %rdi
callq 0x3170
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3170
jmp 0xf10a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xf072
movq -0x48(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x90(%rax), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x5c, %eax
jne 0xf181
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xf1b9
movsbl -0x19(%rbp), %eax
cmpl $0x2f, %eax
jne 0xf198
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xf1c7
movsbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0xf1b5
movq -0x58(%rbp), %rsi
movq -0x68(%rbp), %rdi
xorl %edx, %edx
callq 0xe720
jmp 0xf272
jmp 0xf1b7
jmp 0xf1b9
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xf155
movq -0x58(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1a(%rbp)
movsbl -0x1a(%rbp), %ecx
xorl %eax, %eax
cmpl $0x61, %ecx
movb %al, -0x69(%rbp)
jl 0xf1f7
movsbl -0x1a(%rbp), %eax
cmpl $0x7a, %eax
setle %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0xf200
jmp 0xf223
movq -0x58(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb 0x1(%rax,%rcx), %al
movb %al, -0x1a(%rbp)
jmp 0xf1dc
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xf420
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x78(%rbp), %rcx
movl $0x4, %edx
callq 0xf330
jmp 0xf250
leaq -0x40(%rbp), %rdi
callq 0x3170
jmp 0xf272
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3170
jmp 0xf27f
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3460
nopl (%rax,%rax)
// File: jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::makeToken(jshund::TokenType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Token makeToken (TokenType type, std::string const& v) {
        Token token;
        token.type  = type;
        token.line  = _line;
        token.value = v;
        
        _position += v.size();

        //std::cout << "token: " << type << "," << v << std::endl;

        return token;
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x21(%rbp)
callq 0xf5a0
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl %ecx, (%rdi)
movq 0x98(%rax), %rax
movq %rax, 0x28(%rdi)
movq -0x20(%rbp), %rsi
addq $0x8, %rdi
callq 0x3050
jmp 0xf38a
movq -0x20(%rbp), %rdi
callq 0x31b0
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq 0x90(%rax), %rcx
movq %rcx, 0x90(%rax)
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0xf3d4
jmp 0xf3cb
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xb120
jmp 0xf3de
movq -0x40(%rbp), %rdi
callq 0xb120
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3460
nopw (%rax,%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movl $0x1, -0x1c(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x1d(%rsp)
je 0x2567
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x1d(%rsp)
je 0x2567
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x1d(%rsp)
je 0x2567
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xb, %ecx
movb %al, -0x1d(%rsp)
je 0x2567
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xc, %ecx
movb %al, -0x1d(%rsp)
je 0x2567
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x1d(%rsp)
movb -0x1d(%rsp), %al
testb $0x1, %al
jne 0x2571
jmp 0x2586
jmp 0x2573
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x24f6
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x25ab
movl $0xffffffff, -0x1c(%rsp) # imm = 0xFFFFFFFF
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x25c8
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x25c6
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x25c8
jmp 0x25ca
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x262e
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x25f1
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x2603
movslq -0x1c(%rsp), %rax
imulq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x263e
imulq $0xa, -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movsbq (%rcx), %rcx
addq %rcx, %rax
subq $0x30, %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x25ca
movslq -0x1c(%rsp), %rax
imulq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movl $0x1, -0x1c(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x21(%rsp)
je 0x26d7
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x21(%rsp)
je 0x26d7
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x21(%rsp)
je 0x26d7
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xb, %ecx
movb %al, -0x21(%rsp)
je 0x26d7
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xc, %ecx
movb %al, -0x21(%rsp)
je 0x26d7
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %al
testb $0x1, %al
jne 0x26e1
jmp 0x26f6
jmp 0x26e3
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x2666
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x271b
movl $0xffffffff, -0x1c(%rsp) # imm = 0xFFFFFFFF
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x2738
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x2736
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x2738
jmp 0x273a
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2791
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x20(%rsp)
cmpl $0x9, -0x20(%rsp)
jbe 0x276f
movslq -0x1c(%rsp), %rax
imulq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x27a1
imulq $0xa, -0x18(%rsp), %rax
movl -0x20(%rsp), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x273a
movslq -0x1c(%rsp), %rax
imulq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x21(%rsp)
je 0x282f
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x21(%rsp)
je 0x282f
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x21(%rsp)
je 0x282f
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xb, %ecx
movb %al, -0x21(%rsp)
je 0x282f
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xc, %ecx
movb %al, -0x21(%rsp)
je 0x282f
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %al
testb $0x1, %al
jne 0x2839
jmp 0x284e
jmp 0x283b
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x27be
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x28b0
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x1c(%rsp)
cmpl $0x9, -0x1c(%rsp)
jbe 0x288e
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x2913
imulq $0xa, -0x18(%rsp), %rax
movl -0x1c(%rsp), %ecx
subq %rcx, %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x2869
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x28cb
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x28cd
jmp 0x28cf
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x20(%rsp)
cmpl $0x9, -0x20(%rsp)
jbe 0x28f1
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x2913
imulq $0xa, -0x18(%rsp), %rax
movl -0x20(%rsp), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x28cf
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x680, %rsp            # imm = 0x680
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x23eb
movq 0x7c32(%rip), %rdi      # 0x9fd8
leaq 0x4c6b(%rip), %rsi      # 0x7018
callq 0x2120
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x2120
movq %rax, %rdi
leaq 0x4c57(%rip), %rsi      # 0x7022
callq 0x2120
movq %rax, %rdi
movq 0x7bee(%rip), %rsi      # 0x9fc8
callq 0x2150
movl $0x0, -0x4(%rbp)
jmp 0x2535
callq 0x20d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x330(%rbp), %rdi
callq 0x2550
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x648(%rbp), %rdi
callq 0x2550
jmp 0x241e
leaq -0x330(%rbp), %rdi
callq 0x29f0
jmp 0x242c
leaq -0x648(%rbp), %rdi
movsd 0x4bcd(%rip), %xmm0     # 0x7008
movl $0x3b9aca00, %esi       # imm = 0x3B9ACA00
callq 0x2f70
jmp 0x2447
callq 0x20d0
movq %rax, -0x660(%rbp)
movq 0x7b7e(%rip), %rdi      # 0x9fd8
leaq 0x4bd0(%rip), %rsi      # 0x7031
callq 0x2120
movq %rax, -0x668(%rbp)
jmp 0x246f
movq -0x668(%rbp), %rdi
movq -0x660(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd 0x4b7f(%rip), %xmm1     # 0x7010
divsd %xmm1, %xmm0
callq 0x21f0
movq %rax, -0x670(%rbp)
jmp 0x24a3
movq -0x670(%rbp), %rdi
leaq 0x4b8c(%rip), %rsi      # 0x703d
callq 0x2120
movq %rax, -0x678(%rbp)
jmp 0x24bf
movq -0x678(%rbp), %rdi
movq 0x7afb(%rip), %rsi      # 0x9fc8
callq 0x2150
jmp 0x24d4
movl $0x1, -0x4(%rbp)
leaq -0x648(%rbp), %rdi
callq 0x2970
leaq -0x330(%rbp), %rdi
callq 0x2970
jmp 0x2535
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x650(%rbp)
movl %eax, -0x654(%rbp)
jmp 0x2527
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x650(%rbp)
movl %eax, -0x654(%rbp)
leaq -0x648(%rbp), %rdi
callq 0x2970
leaq -0x330(%rbp), %rdi
callq 0x2970
jmp 0x2541
movl -0x4(%rbp), %eax
addq $0x680, %rsp            # imm = 0x680
popq %rbp
retq
movq -0x650(%rbp), %rdi
callq 0x21d0
nopl (%rax)
// File: SilentAssassinMa[P]Sudoku-Solver/SudokuSolver.cpp
// Function: SudokuSolver::CheckEmpty(int*)
bool SudokuSolver::CheckEmpty(int *sudoku)
{
    for (int i = 0; i < 81; i++)
    {
        if (sudoku[i] == 0)
        {
            return true;
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x51, -0x1c(%rbp)
jge 0x38fa
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x38ed
movb $0x1, -0x1(%rbp)
jmp 0x38fe
jmp 0x38ef
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x38d3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0x9, -0x14(%rbp)
jg 0x3f7b
movl -0x14(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
jne 0x3ec3
movq 0x6130(%rip), %rdi      # 0x9fd8
leaq 0x329e(%rip), %rsi      # 0x714d
callq 0x2120
movq %rax, %rdi
movq 0x610a(%rip), %rsi      # 0x9fc8
callq 0x2150
movq 0x610e(%rip), %rdi      # 0x9fd8
leaq 0x3290(%rip), %rsi      # 0x7161
callq 0x2120
movl $0x1, -0x18(%rbp)
cmpl $0x9, -0x18(%rbp)
jg 0x3f5a
movl -0x18(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x3f21
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x40b0
movl %eax, %esi
movq 0x60cd(%rip), %rdi      # 0x9fd8
callq 0x21c0
movq %rax, %rdi
leaq 0x3247(%rip), %rsi      # 0x7161
callq 0x2120
jmp 0x3f4d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x40b0
movl %eax, %esi
movq 0x609f(%rip), %rdi      # 0x9fd8
callq 0x21c0
movq %rax, %rdi
leaq 0x30d8(%rip), %rsi      # 0x7020
callq 0x2120
jmp 0x3f4f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3edd
movq 0x6077(%rip), %rdi      # 0x9fd8
movq 0x6060(%rip), %rsi      # 0x9fc8
callq 0x2150
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3e87
movq 0x6056(%rip), %rdi      # 0x9fd8
leaq 0x31c4(%rip), %rsi      # 0x714d
callq 0x2120
movq %rax, %rdi
movq 0x6030(%rip), %rsi      # 0x9fc8
callq 0x2150
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mh0fm4[P]SCDC/test/units/dataprov_store/test_store.c
// Function: main
int main(int argc, char *argv[])
{
  const char *uri = "scdc:/store";
  scdc_dataprov_t dp;


  printf("SCDC storage demo for C\n");

  scdc_init(SCDC_INIT_DEFAULT);

  // dp = scdc_dataprov_open("store", "store:stub");
  dp = scdc_dataprov_open("store", "store:fs", STORE_FS_CONF);
  // dp = scdc_dataprov_open("store", "store:mysql", STORE_MYSQL_CONF);
  // dp = scdc_dataprov_open("store", "store:webdav:no100continue", STORE_WEBDAV_CONF);
  // dp = scdc_dataprov_open("store", "store:webdav:username:password", STORE_WEBDAV_CONF, "foo", "bar");
  // dp = scdc_dataprov_open("store", "store:webdav:username:password", STORE_WEBDAV_CONF, "xxxdavtest", "dasisteintest");
  // dp = scdc_dataprov_open("store", "nfs:store", STORE_NFS_CONF);

  test_store(uri);

  scdc_dataprov_close(dp);

  scdc_release();

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7b62a(%rip), %rax     # 0x89297
movq %rax, -0x18(%rbp)
leaq 0x7b62b(%rip), %rdi     # 0x892a3
movb $0x0, %al
callq 0xcd00
leaq 0x7bade(%rip), %rdi     # 0x89764
movb $0x0, %al
callq 0xdd40
leaq 0x7c0ea(%rip), %rdi     # 0x89d7e
leaq 0x7b621(%rip), %rsi     # 0x892bc
leaq 0x7b623(%rip), %rdx     # 0x892c5
movb $0x0, %al
callq 0xe270
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd7e0
movq -0x20(%rbp), %rdi
callq 0xe340
callq 0xdef0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x1b0(%rbp), %rdi
leaq 0xa788(%rip), %rsi      # 0xe010
movl $0x6c, %edx
callq 0x3300
movq $0x0, -0x1b8(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x1b0(%rbp), %rdx
leaq -0x1bc(%rbp), %rcx
callq 0x3530
movq %rax, -0x1c8(%rbp)
cmpq $0x0, -0x1c8(%rbp)
je 0x38ee
cmpl $0x1, -0x1bc(%rbp)
jl 0x38e2
movq -0x1c8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1b8(%rbp)
movq -0x1c8(%rbp), %rdi
callq 0x34b0
cmpq $0x0, -0x1b8(%rbp)
jne 0x391a
movq 0xf6e1(%rip), %rax      # 0x12fe0
movq (%rax), %rdi
leaq 0xa773(%rip), %rsi      # 0xe07c
movb $0x0, %al
callq 0x3590
movq $0x0, -0x8(%rbp)
jmp 0x3936
movq -0x10(%rbp), %rdi
movq -0x1b8(%rbp), %rsi
callq 0x3570
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: intheswim[P]FractalTubes/main.cpp
// Function: argvOptions::argvOptions()
argvOptions ()
    {
        standalone = true;
        verbose = false;
        useLog = false;
        smooth = true; 

        detail = DEF_DETAIL_LEVEL;
        interval = DEF_INTERVAL;
        palette = DEF_PALETTE;
        light_source = DEF_LIGHT_SOURCE;
        transparency = DEF_TRANSPARENCY;
        rotation_speed = DEF_ROTATION_SPEED;
        dist2light = DEF_LIGHT_DISTANCE;
        gloss_level = DEF_GLOSS_LEVEL;
        two_sided_light = DEF_2_SIDED_LIGHT;
        shuffle = DEF_SHUFFLE;
        delay_ms = 10;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
movb $0x0, 0x1(%rax)
movb $0x0, 0x2(%rax)
movl $0x1, 0x30(%rax)
movl $0x1, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x2, 0x10(%rax)
movl $0x2, 0x14(%rax)
movl $0x1, 0x1c(%rax)
movl $0x19, 0x18(%rax)
movl $0xa, 0x24(%rax)
movl $0x0, 0x28(%rax)
movb $0x1, 0x2c(%rax)
movb $0x0, 0x2d(%rax)
movl $0xa, 0x4(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: intheswim[P]FractalTubes/infra.cpp
// Function: closeLog()
void closeLog ()
{
#ifndef _DEBUG
   if (log1)
   {
      fputs ("Closing log\n", log1);
      fclose (log1);
      log1 = 0;
   }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0xefcc(%rip)      # 0x13528
je 0x4588
movq 0xefc3(%rip), %rsi      # 0x13528
leaq 0x9df0(%rip), %rdi      # 0xe35c
callq 0x3410
movq 0xefb0(%rip), %rdi      # 0x13528
callq 0x3370
movq $0x0, 0xefa0(%rip) # 0x13528
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cvtsi2ssl -0x8(%rbp), %xmm0
movss %xmm0, 0xef59(%rip)     # 0x13544
cvtsi2ssl -0x4(%rbp), %xmm0
movss %xmm0, 0xef50(%rip)     # 0x13548
movl -0x4(%rbp), %edx
movl -0x8(%rbp), %ecx
xorl %esi, %esi
movl %esi, %edi
callq 0x30e0
movl $0x1701, %edi           # imm = 0x1701
callq 0x3520
callq 0x34e0
cvtsi2ssl -0x4(%rbp), %xmm0
cvtsi2ssl -0x8(%rbp), %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x9c08(%rip), %xmm0     # 0xe238
movsd 0x9c08(%rip), %xmm2     # 0xe240
movsd 0x9c08(%rip), %xmm3     # 0xe248
callq 0x3450
movl $0x1700, %edi           # imm = 0x1700
callq 0x3520
callq 0x34e0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: intheswim[P]FractalTubes/infra.cpp
// Function: setUpOpenGL()
static void setUpOpenGL (void)
{    
    glEnable(GL_POLYGON_SMOOTH);
    //glHint(GL_POLYGON_SMOOTH_HINT, GL_DONT_CARE);
    glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);

    glEnable(GL_LINE_SMOOTH);
    
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	
    if (m_Preview)
    {
        glClearColor( 0.0f, 0.0f, 0.125f, 0.0f );
    }
    else
    {
	    glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
    }

	glClearDepth( 1.0f ); // default is 1; range from 0 to 1
	glEnable( GL_DEPTH_TEST );
    
	glDepthFunc( GL_LEQUAL );
    
    glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
    
    glDisable (GL_NORMALIZE);
    
    if (USE_LIGHT)
    {        
        glShadeModel( SHADE_MODE );

        // both needed to enable light:
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
    
        // without this call everything is gray
        glEnable ( GL_COLOR_MATERIAL ) ;
    }
        
	rotation = 0.0f;
            
    rollover();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xb41, %edi            # imm = 0xB41
callq 0x3340
movl $0xc53, %edi            # imm = 0xC53
movl $0x1102, %esi           # imm = 0x1102
callq 0x3360
movl $0xb20, %edi            # imm = 0xB20
callq 0x3340
movl $0xbe2, %edi            # imm = 0xBE2
callq 0x3340
movl $0x302, %edi            # imm = 0x302
movl $0x303, %esi            # imm = 0x303
callq 0x32b0
testb $0x1, 0xee89(%rip)      # 0x13540
je 0x46d1
xorps %xmm3, %xmm3
movss 0x9c14(%rip), %xmm2     # 0xe2d8
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
callq 0x35d0
jmp 0x46e2
xorps %xmm3, %xmm3
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
callq 0x35d0
movsd 0x9b66(%rip), %xmm0     # 0xe250
callq 0x3420
movl $0xb71, %edi            # imm = 0xB71
callq 0x3340
movl $0x203, %edi            # imm = 0x203
callq 0x3200
movl $0xc50, %edi            # imm = 0xC50
movl $0x1102, %esi           # imm = 0x1102
callq 0x3360
movl $0xba1, %edi            # imm = 0xBA1
callq 0x30d0
testb $0x1, 0xee35(%rip)      # 0x13558
je 0x474d
movl $0x1d01, %edi           # imm = 0x1D01
callq 0x3670
movl $0xb50, %edi            # imm = 0xB50
callq 0x3340
movl $0x4000, %edi           # imm = 0x4000
callq 0x3340
movl $0xb57, %edi            # imm = 0xB57
callq 0x3340
xorps %xmm0, %xmm0
movss %xmm0, 0xedf8(%rip)     # 0x13550
callq 0x5ae0
popq %rbp
retq
nop
// File: intheswim[P]FractalTubes/infra.cpp
// Function: sortByDistanceToEye(float, float, float, corePointData*, long)
static void sortByDistanceToEye (float eye_x, float eye_y, float eye_z,
                          struct corePointData * pointData, long cnt)
{    
    for (int i=0; i < cnt; i++)
    {
        struct corePointData * pd = pointData + i;
        
        pd->dist = (pd->x - eye_x) * (pd->x - eye_x) +
            (pd->y - eye_y) * (pd->y - eye_y) + (pd->z - eye_z) * (pd->z - eye_z);
    }
      
    // prsemuably faster than qsort:
    std::sort (pointData, pointData + cnt, &compareByDist);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x5ab4
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsd (%rax), %xmm1
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
subsd %xmm0, %xmm1
movq -0x30(%rbp), %rax
movsd (%rax), %xmm2
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
subsd %xmm0, %xmm2
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm0
movss -0x8(%rbp), %xmm3
cvtss2sd %xmm3, %xmm3
subsd %xmm3, %xmm0
movq -0x30(%rbp), %rax
movsd 0x8(%rax), %xmm3
movss -0x8(%rbp), %xmm4
cvtss2sd %xmm4, %xmm4
subsd %xmm4, %xmm3
mulsd %xmm3, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm0
movss -0xc(%rbp), %xmm2
cvtss2sd %xmm2, %xmm2
subsd %xmm2, %xmm0
movq -0x30(%rbp), %rax
movsd 0x10(%rax), %xmm2
movss -0xc(%rbp), %xmm3
cvtss2sd %xmm3, %xmm3
subsd %xmm3, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x59e6
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
imulq $0x28, -0x20(%rbp), %rax
addq %rax, %rsi
leaq -0x136b(%rip), %rdx     # 0x4760
callq 0x68a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0xd678(%rip)      # 0x13568
jle 0x5f31
movq 0xd637(%rip), %rax      # 0x13530
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x5f0c
movq -0x8(%rbp), %rdi
callq 0x34c0
movq 0xd625(%rip), %rax      # 0x13538
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5f26
movq -0x10(%rbp), %rdi
callq 0x34c0
movq $0x0, 0xd607(%rip) # 0x13538
movq $0x0, 0xd62c(%rip) # 0x13568
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq $0x0, 0xd019(%rip) # 0x13568
movl $0x0, 0xd033(%rip)      # 0x1358c
movb 0xcfe1(%rip), %al       # 0x13540
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6578
movl $0xffffffff, 0xd019(%rip) # imm = 0xFFFFFFFF
callq 0x6290
movq $0x0, 0xcfb5(%rip) # 0x13538
xorl %eax, %eax
movl %eax, %edi
callq 0x3330
movl %eax, %edi
callq 0x3350
callq 0xb460
movss %xmm0, 0xcfd8(%rip)     # 0x13578
callq 0xb4d0
movss 0x7d5b(%rip), %xmm1     # 0xe308
mulss %xmm1, %xmm0
movss %xmm0, 0xcfc3(%rip)     # 0x1357c
callq 0xb5a0
movss %xmm0, 0xcfba(%rip)     # 0x13580
callq 0xb620
movl %eax, 0xcfb3(%rip)      # 0x13584
callq 0xb7a0
movl %eax, 0xcfac(%rip)      # 0x13588
callq 0xb810
andb $0x1, %al
movb %al, 0xcf6f(%rip)       # 0x13558
callq 0xb8b0
cvttss2si %xmm0, %rax
movq %rax, 0xcf9e(%rip)      # 0x13598
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x84f3
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x84f3
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
shll $0x4, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xff, %eax
cltq
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
sarl $0x4, %eax
movl %eax, -0xc(%rbp)
jmp 0x8502
movl -0xc(%rbp), %eax
andl $0xf, %eax
shll $0x4, %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
andl $0x30, %ecx
shll $0xa, %ecx
movslq %ecx, %rcx
addq -0x18(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %ecx
andl $0xc0, %ecx
shll $0x10, %ecx
movslq %ecx, %rcx
addq -0x18(%rbp), %rcx
movq %rcx, -0x18(%rbp)
testb $0x1, 0x68(%rax)
je 0x854d
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movl 0x6c(%rax), %esi
callq 0x8560
movq %rax, -0x28(%rbp)
jmp 0x8555
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
andq $0xff, %rax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
sarq $0x8, %rax
andq $0xff, %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
sarq $0x10, %rax
andq $0xff, %rax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
sarl $0x6, %eax
cmpl $0x0, %eax
jle 0x86a3
movl -0x18(%rbp), %eax
sarl $0x6, %eax
cmpl $0x4, %eax
jge 0x86a3
cmpl $0x0, -0x14(%rbp)
jne 0x86a3
movl -0x10(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x85eb
movl -0x10(%rbp), %eax
sarl $0x2, %eax
movl $0x3f, %ecx
subl %eax, %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x8683
cmpl $0x1, -0xc(%rbp)
jne 0x8635
movl -0x18(%rbp), %eax
sarl $0x6, %eax
cmpl $0x3, %eax
jne 0x8613
movl -0x10(%rbp), %eax
sarl $0x2, %eax
movl $0x3f, %ecx
subl %eax, %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x8633
movl -0x18(%rbp), %eax
sarl $0x6, %eax
cmpl $0x1, %eax
jne 0x8631
movl -0x10(%rbp), %ecx
sarl $0x2, %ecx
movl $0x3f, %eax
subl %ecx, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x8633
jmp 0x8681
cmpl $0x2, -0xc(%rbp)
jne 0x867f
movl -0x18(%rbp), %eax
sarl $0x6, %eax
cmpl $0x3, %eax
jne 0x865b
movl -0x10(%rbp), %ecx
sarl $0x2, %ecx
movl $0x3f, %eax
subl %ecx, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x867d
movl -0x18(%rbp), %eax
sarl $0x6, %eax
cmpl $0x1, %eax
jne 0x867b
movl -0x10(%rbp), %eax
sarl $0x2, %eax
movl $0x3f, %ecx
subl %eax, %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x867d
jmp 0x867f
jmp 0x8681
jmp 0x8683
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0x18(%rbp), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movl -0x14(%rbp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
cltq
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
fldt 0x40(%rbp)
fldt 0x30(%rbp)
fldt 0x20(%rbp)
fldt 0x10(%rbp)
movq %rdi, -0x8(%rbp)
fstpt -0x20(%rbp)
fstpt -0x30(%rbp)
fstpt -0x40(%rbp)
fstpt -0x50(%rbp)
movq %rsi, -0x58(%rbp)
movq %rdx, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x108(%rbp)
movl $0x0, -0x64(%rbp)
fldz
fstpt -0xe0(%rbp)
fldt -0x40(%rbp)
fstpt -0x80(%rbp)
fldt -0x50(%rbp)
fstpt -0x90(%rbp)
fldt -0x80(%rbp)
fmul %st, %st(0)
fstpt -0xc0(%rbp)
fldt -0x90(%rbp)
fmul %st, %st(0)
fstpt -0xd0(%rbp)
fldt -0xc0(%rbp)
fldt -0xd0(%rbp)
faddp %st, %st(1)
fstpt -0xf0(%rbp)
fldt -0xf0(%rbp)
flds 0x5c7b(%rip)            # 0xe3bc
fucompi %st(1), %st
fstp %st(0)
jb 0x87af
jmp 0x8749
cmpl $0x100, -0x64(%rbp)     # imm = 0x100
jge 0x87af
fldt -0xf0(%rbp)
fstpt -0xe0(%rbp)
fldt -0xc0(%rbp)
fldt -0xd0(%rbp)
fsubrp %st, %st(1)
fstpt -0xa0(%rbp)
fldt -0x80(%rbp)
fadd %st, %st(0)
fldt -0x90(%rbp)
fmulp %st, %st(1)
fstpt -0xb0(%rbp)
fldt -0xa0(%rbp)
fldt -0x20(%rbp)
faddp %st, %st(1)
fstpt -0x80(%rbp)
fldt -0xb0(%rbp)
fldt -0x30(%rbp)
faddp %st, %st(1)
fstpt -0x90(%rbp)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x87b1
jmp 0x87bf
jmp 0x87b3
movb $0x1, %al
testb $0x1, %al
jne 0x8708
jmp 0x87bf
movq $0x0, -0xf8(%rbp)
movq -0x60(%rbp), %rax
movl $0x0, (%rax)
movl -0x64(%rbp), %ecx
movq -0x58(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x64(%rbp)
jle 0x8843
cmpl $0x100, -0x64(%rbp)     # imm = 0x100
jge 0x8843
fldt -0xe0(%rbp)
flds 0x5bc4(%rip)            # 0xe3bc
fsub %st(1), %st
flds 0x5bc0(%rip)            # 0xe3c0
fmulp %st, %st(1)
fldt -0xf0(%rbp)
fsubp %st, %st(2)
fdivp %st, %st(1)
fnstcw -0xfe(%rbp)
movzwl -0xfe(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x100(%rbp)
fldcw -0x100(%rbp)
fistpl -0xfc(%rbp)
fldcw -0xfe(%rbp)
movl -0xfc(%rbp), %ecx
movq -0x60(%rbp), %rax
movl %ecx, (%rax)
movq -0x108(%rbp), %rdi
movl -0x64(%rbp), %esi
movq -0x60(%rbp), %rax
movl (%rax), %edx
callq 0x84a0
movq %rax, -0xf8(%rbp)
movq -0xf8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
fldt 0x20(%rbp)
fldt 0x10(%rbp)
movq %rdi, -0x8(%rbp)
fstpt -0x20(%rbp)
fstpt -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movl $0x0, -0x44(%rbp)
fldz
fstpt -0xc0(%rbp)
fldt -0x20(%rbp)
fstpt -0x60(%rbp)
fldt -0x30(%rbp)
fstpt -0x70(%rbp)
fldt -0x60(%rbp)
fmul %st, %st(0)
fstpt -0xa0(%rbp)
fldt -0x70(%rbp)
fmul %st, %st(0)
fstpt -0xb0(%rbp)
fldt -0xa0(%rbp)
fldt -0xb0(%rbp)
faddp %st, %st(1)
fstpt -0xd0(%rbp)
fldt -0xd0(%rbp)
flds 0x5acd(%rip)            # 0xe3bc
fucompi %st(1), %st
fstp %st(0)
jb 0x8951
jmp 0x88f7
cmpl $0x100, -0x44(%rbp)     # imm = 0x100
jge 0x8951
fldt -0xd0(%rbp)
fstpt -0xc0(%rbp)
fldt -0xa0(%rbp)
fldt -0xb0(%rbp)
fsubrp %st, %st(1)
fstpt -0x80(%rbp)
fldt -0x60(%rbp)
fadd %st, %st(0)
fldt -0x70(%rbp)
fmulp %st, %st(1)
fstpt -0x90(%rbp)
fldt -0x80(%rbp)
fldt -0x20(%rbp)
faddp %st, %st(1)
fstpt -0x60(%rbp)
fldt -0x90(%rbp)
fldt -0x30(%rbp)
faddp %st, %st(1)
fstpt -0x70(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x8953
jmp 0x8961
jmp 0x8955
movb $0x1, %al
testb $0x1, %al
jne 0x88b9
jmp 0x8961
movq $0x0, -0xd8(%rbp)
movq -0x40(%rbp), %rax
movl $0x0, (%rax)
movl -0x44(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x44(%rbp)
jle 0x89e5
cmpl $0x100, -0x44(%rbp)     # imm = 0x100
jge 0x89e5
fldt -0xc0(%rbp)
flds 0x5a22(%rip)            # 0xe3bc
fsub %st(1), %st
flds 0x5a1e(%rip)            # 0xe3c0
fmulp %st, %st(1)
fldt -0xd0(%rbp)
fsubp %st, %st(2)
fdivp %st, %st(1)
fnstcw -0xde(%rbp)
movzwl -0xde(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0xe0(%rbp)
fldcw -0xe0(%rbp)
fistpl -0xdc(%rbp)
fldcw -0xde(%rbp)
movl -0xdc(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0xe8(%rbp), %rdi
movl -0x44(%rbp), %esi
movq -0x40(%rbp), %rax
movl (%rax), %edx
callq 0x84a0
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::M3DDrawer(float, float)
M3DDrawer::M3DDrawer (float w, float h)
{
    client_width = w;
    client_height = h;

	assert (client_width > 0 && client_height > 0);
    
    bright_k = 1;
    
    alternate_palette = false;
    
    pal_case = PALETTE_STD;
    
    m_total_points = 0;
    
#ifdef USE_RUNTIME
    set_gamma = set_tilt = 0;
#endif
    
    rotationArray = NULL;
    spArray = NULL;
	InitRotationArray ();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x30(%rax)
movss -0x10(%rbp), %xmm0
movss %xmm0, 0x34(%rax)
movss 0x30(%rax), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
movb %al, -0x11(%rbp)
jbe 0x8a79
movq -0x20(%rbp), %rax
movss 0x34(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
seta %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x8a82
jmp 0x8a84
jmp 0x8aa3
leaq 0x5a65(%rip), %rdi      # 0xe4f0
leaq 0x5a84(%rip), %rsi      # 0xe516
movl $0x106, %edx            # imm = 0x106
leaq 0x5a80(%rip), %rcx      # 0xe51e
callq 0x3220
movq -0x20(%rbp), %rdi
movl $0x1, 0x64(%rdi)
movb $0x0, 0x68(%rdi)
movl $0x0, 0x6c(%rdi)
movq $0x0, 0x58(%rdi)
movq $0x0, 0x48(%rdi)
movq $0x0, 0x50(%rdi)
callq 0x8ae0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movl %edx, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movq 0x48(%rax), %rsi
movslq -0xc(%rbp), %rax
imulq $0xd0, %rax, %rax
addq %rax, %rsi
movl $0xd0, %edx
callq 0x3300
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movq 0x50(%rax), %rsi
movslq -0xc(%rbp), %rax
imulq $0x70, %rax, %rax
addq %rax, %rsi
movl $0x70, %edx
callq 0x3300
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x178(%rbp)
movb $0x0, -0x21(%rbp)
testb $0x1, -0xd(%rbp)
je 0x92fc
leaq -0x100(%rbp), %rdi
leaq 0xa14c(%rip), %rsi      # 0x133e0
movl $0xd0, %edx
callq 0x3300
leaq -0x170(%rbp), %rdi
leaq 0xa204(%rip), %rsi      # 0x134b0
movl $0x70, %edx
callq 0x3300
movq -0x178(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x100(%rbp), %rdx
leaq -0x170(%rbp), %rcx
callq 0x90f0
movq -0x178(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq -0x170(%rbp), %rsi
leaq -0x100(%rbp), %rdx
callq 0x9310
andb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x92fe
jmp 0x92fe
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopl (%rax)