LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jswaff[P]prophet3/test/utils__test.cpp
// Function: test_gs_draw50()
void test_gs_draw50() {
    reset_pos(&gpos);

    gpos.fifty_counter=gpos.move_counter=49;
    assert(get_game_status()==INPROGRESS);

    gpos.fifty_counter=gpos.move_counter=50;
    assert(get_game_status()==INPROGRESS);

    gpos.fifty_counter=gpos.move_counter=51;
    assert(get_game_status()==INPROGRESS);

    gpos.fifty_counter=gpos.move_counter=100;
    assert(get_game_status()==DRAW_BY_50);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9fb55(%rip), %rdi     # 0xd3ae0
callq 0xf390
leaq 0x9fb49(%rip), %rax     # 0xd3ae0
movl $0x31, 0x144(%rax)
leaq 0x9fb38(%rip), %rax     # 0xd3ae0
movl $0x31, 0x148(%rax)
callq 0x14e20
cmpl $0x0, %eax
jne 0x33fbe
jmp 0x33fdd
leaq 0x10d53(%rip), %rdi     # 0x44d18
leaq 0x108b0(%rip), %rsi     # 0x4487c
movl $0xd5, %edx
leaq 0x10e97(%rip), %rcx     # 0x44e6f
callq 0x20c0
leaq 0x9fafc(%rip), %rax     # 0xd3ae0
movl $0x32, 0x144(%rax)
leaq 0x9faeb(%rip), %rax     # 0xd3ae0
movl $0x32, 0x148(%rax)
callq 0x14e20
cmpl $0x0, %eax
jne 0x3400b
jmp 0x3402a
leaq 0x10d06(%rip), %rdi     # 0x44d18
leaq 0x10863(%rip), %rsi     # 0x4487c
movl $0xd8, %edx
leaq 0x10e4a(%rip), %rcx     # 0x44e6f
callq 0x20c0
leaq 0x9faaf(%rip), %rax     # 0xd3ae0
movl $0x33, 0x144(%rax)
leaq 0x9fa9e(%rip), %rax     # 0xd3ae0
movl $0x33, 0x148(%rax)
callq 0x14e20
cmpl $0x0, %eax
jne 0x34058
jmp 0x34077
leaq 0x10cb9(%rip), %rdi     # 0x44d18
leaq 0x10816(%rip), %rsi     # 0x4487c
movl $0xdb, %edx
leaq 0x10dfd(%rip), %rcx     # 0x44e6f
callq 0x20c0
leaq 0x9fa62(%rip), %rax     # 0xd3ae0
movl $0x64, 0x144(%rax)
leaq 0x9fa51(%rip), %rax     # 0xd3ae0
movl $0x64, 0x148(%rax)
callq 0x14e20
cmpl $0x4, %eax
jne 0x340a5
jmp 0x340c4
leaq 0x10dd9(%rip), %rdi     # 0x44e85
leaq 0x107c9(%rip), %rsi     # 0x4487c
movl $0xde, %edx
leaq 0x10db0(%rip), %rcx     # 0x44e6f
callq 0x20c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jswaff[P]prophet3/test/utils__test.cpp
// Function: test_utils()
void test_utils() {
    test_opposite_player();
    test_str_to_sq();
    test_sq_to_str();
    test_move_to_str();
    test_str_to_move();
    test_is_in_move_list();
    test_is_legal_move();
    test_is_white_piece();
    test_is_black_piece();
    test_is_not_white_piece();
    test_is_not_black_piece();

    test_gs_initial_pos();
    test_gs_checkmate_foolsmate();
    test_gs_checkmate_byrnefischer();
    test_gs_checkmate_simplemate();
    test_gs_stalemate();
    test_gs_stalemate_burnpilsbury();
    test_gs_stalemate_2();
    test_gs_stalemate_3();
    test_gs_draw50();
    test_gs_no_material();
    test_gs_no_material_one_pawn();
    test_gs_no_material_one_knight();
    test_gs_no_material_one_bishop();
    test_gs_no_material_one_rook();
    test_gs_no_material_one_queen();
    test_gs_no_material_just_kings();
    test_gs_no_material_two_white_knights();
    test_gs_no_material_two_opposing_knights();
    test_gs_no_material_two_bishops_different_colors();
    test_gs_no_material_two_bishops_same_color();
    test_gs_no_material_bishop_vs_knight();
    test_gs_draw_by_rep();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x32f90
callq 0x33000
callq 0x330d0
callq 0x331d0
callq 0x33320
callq 0x33880
callq 0x339c0
callq 0x33a90
callq 0x33b30
callq 0x33bd0
callq 0x33c70
callq 0x33d10
callq 0x33d50
callq 0x33da0
callq 0x33df0
callq 0x33e40
callq 0x33e90
callq 0x33ee0
callq 0x33f30
callq 0x33f80
callq 0x340d0
callq 0x34120
callq 0x34170
callq 0x341c0
callq 0x34210
callq 0x34260
callq 0x342b0
callq 0x34300
callq 0x34350
callq 0x343a0
callq 0x343f0
callq 0x34440
callq 0x34490
popq %rbp
retq
// File: tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parse()
void ObjParser<Stream>::parse()
{
    nextToken();
    while(true)
    {
        if(accept(TokenType::COMMENT));
        else if(parseVertex());
        else if(parseNormal());
        else if(parseTexCo());
        else if(parseFace());
        else if(parseUseMtl());
        else if(parseMtlLib());
        else if(parseObject());
        else if(parseGroup());
        else if(parseShade());
        if(!accept(TokenType::END_OF_LINE))
        {
            expect(TokenType::END_OF_FILE);
            break;
        }
    }
    done = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x6c50
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x73b0
testb $0x1, %al
jne 0x4c8a
jmp 0x4c8f
jmp 0x4d40
movq -0x10(%rbp), %rdi
callq 0x73f0
testb $0x1, %al
jne 0x4c9e
jmp 0x4ca3
jmp 0x4d3e
movq -0x10(%rbp), %rdi
callq 0x74f0
testb $0x1, %al
jne 0x4cb2
jmp 0x4cb7
jmp 0x4d3c
movq -0x10(%rbp), %rdi
callq 0x75a0
testb $0x1, %al
jne 0x4cc6
jmp 0x4cc8
jmp 0x4d3a
movq -0x10(%rbp), %rdi
callq 0x76a0
testb $0x1, %al
jne 0x4cd7
jmp 0x4cd9
jmp 0x4d38
movq -0x10(%rbp), %rdi
callq 0x7c60
testb $0x1, %al
jne 0x4ce8
jmp 0x4cea
jmp 0x4d36
movq -0x10(%rbp), %rdi
callq 0x7cd0
testb $0x1, %al
jne 0x4cf9
jmp 0x4cfb
jmp 0x4d34
movq -0x10(%rbp), %rdi
callq 0x7d40
testb $0x1, %al
jne 0x4d0a
jmp 0x4d0c
jmp 0x4d32
movq -0x10(%rbp), %rdi
callq 0x7db0
testb $0x1, %al
jne 0x4d1b
jmp 0x4d1d
jmp 0x4d30
movq -0x10(%rbp), %rdi
callq 0x7e20
testb $0x1, %al
jne 0x4d2c
jmp 0x4d2e
jmp 0x4d2e
jmp 0x4d30
jmp 0x4d32
jmp 0x4d34
jmp 0x4d36
jmp 0x4d38
jmp 0x4d3a
jmp 0x4d3c
jmp 0x4d3e
jmp 0x4d40
movq -0x10(%rbp), %rdi
movl $0xf, %esi
callq 0x73b0
testb $0x1, %al
jne 0x4d62
movq -0x10(%rbp), %rdi
movl $0xc, %esi
callq 0x7ef0
jmp 0x4d67
jmp 0x4c79
movq -0x10(%rbp), %rax
movb $0x1, 0x99(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::accept(ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::TokenType)
bool accept(TokenType type)
    {
        if(token_type == type)
        {
            nextToken();
            return true;
        }
        else
            return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0xe0(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x73e1
movq -0x20(%rbp), %rdi
callq 0x6c50
movb $0x1, -0x1(%rbp)
jmp 0x73e5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseVertex()
bool parseVertex()
    {
        if(accept(TokenType::VERTEX))
        {
            tmat::Vector4f vertex;
            int index = 0;

            while(expect(TokenType::NUMBER))
            {
                vertex[index] = stof(token);
                index ++;
                if(index >= 3)
                    break;
            }

            if(accept(TokenType::NUMBER))
            {
                vertex[index] = stof(token);
                index ++;
            }

            /* Add the vertex to the list of vertices. */
            vertices.push_back(vertex);
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x1, %esi
callq 0x73b0
testb $0x1, %al
jne 0x7417
jmp 0x74d8
leaq -0x18(%rbp), %rdi
callq 0x80d0
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl $0xb, %esi
callq 0x7ef0
testb $0x1, %al
jne 0x743b
jmp 0x747c
movq -0x28(%rbp), %rdi
addq $0xa0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8110
movss %xmm0, -0x2c(%rbp)
movl -0x1c(%rbp), %esi
leaq -0x18(%rbp), %rdi
callq 0x8150
movss -0x2c(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jl 0x747a
jmp 0x747c
jmp 0x7427
movq -0x28(%rbp), %rdi
movl $0xb, %esi
callq 0x73b0
testb $0x1, %al
jne 0x7490
jmp 0x74c7
movq -0x28(%rbp), %rdi
addq $0xa0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8110
movss %xmm0, -0x30(%rbp)
movl -0x1c(%rbp), %esi
leaq -0x18(%rbp), %rdi
callq 0x8150
movss -0x30(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x8170
xorl %eax, %eax
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseNormal()
bool parseNormal()
    {
        if(accept(TokenType::NORMAL))
        {
            tmat::Vector3f vertex;
            int index = 0;

            while(expect(TokenType::NUMBER))
            {
                vertex[index] = stof(token);
                index ++;
                if(index >= 3)
                    break;
            }
            
            /* Add the normal to the list of normals. */
            normals.push_back(vertex);
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x2, %esi
callq 0x73b0
testb $0x1, %al
jne 0x7514
jmp 0x758a
leaq -0x14(%rbp), %rdi
callq 0x8cc0
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movl $0xb, %esi
callq 0x7ef0
testb $0x1, %al
jne 0x7538
jmp 0x7579
movq -0x20(%rbp), %rdi
addq $0xa0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8110
movss %xmm0, -0x24(%rbp)
movl -0x18(%rbp), %esi
leaq -0x14(%rbp), %rdi
callq 0x8d00
movss -0x24(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jl 0x7577
jmp 0x7579
jmp 0x7524
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
leaq -0x14(%rbp), %rsi
callq 0x8d20
xorl %eax, %eax
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseTexCo()
bool parseTexCo()
    {
        if(accept(TokenType::TEXCO))
        {
            tmat::Vector2f vertex;
            int index = 0;

            while(expect(TokenType::NUMBER))
            {
                vertex[index] = stof(token);
                index ++;
                if(index >= 1)
                    break;
            }

            if(accept(TokenType::NUMBER))
            {
                vertex[index] = stof(token);
                index ++;
            }

            /* Add the texco to the list of texcos. */
            texCos.push_back(vertex);
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x3, %esi
callq 0x73b0
testb $0x1, %al
jne 0x75c7
jmp 0x7688
leaq -0x10(%rbp), %rdi
callq 0x9670
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl $0xb, %esi
callq 0x7ef0
testb $0x1, %al
jne 0x75eb
jmp 0x762c
movq -0x20(%rbp), %rdi
addq $0xa0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8110
movss %xmm0, -0x24(%rbp)
movl -0x14(%rbp), %esi
leaq -0x10(%rbp), %rdi
callq 0x96b0
movss -0x24(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x762a
jmp 0x762c
jmp 0x75d7
movq -0x20(%rbp), %rdi
movl $0xb, %esi
callq 0x73b0
testb $0x1, %al
jne 0x7640
jmp 0x7677
movq -0x20(%rbp), %rdi
addq $0xa0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8110
movss %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %esi
leaq -0x10(%rbp), %rdi
callq 0x96b0
movss -0x28(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
leaq -0x10(%rbp), %rsi
callq 0x96d0
xorl %eax, %eax
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseUseMtl()
bool parseUseMtl()
    {
        if(accept(TokenType::USEMTL))
        {
            parseString();
            expect(TokenType::STRING);
            std::string name = token;

            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x5, %esi
callq 0x73b0
testb $0x1, %al
jne 0x7c84
jmp 0x7cbe
movq -0x38(%rbp), %rdi
callq 0xa920
movq -0x38(%rbp), %rdi
movl $0xe, %esi
callq 0x7ef0
movq -0x38(%rbp), %rsi
addq $0xa0, %rsi
leaq -0x30(%rbp), %rdi
callq 0x3120
movb $0x1, -0x1(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
jmp 0x7cc2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseMtlLib()
bool parseMtlLib()
    {
        if(accept(TokenType::MTLLIB))
        {
            parseString();
            expect(TokenType::STRING);
            std::string path = token;
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x6, %esi
callq 0x73b0
testb $0x1, %al
jne 0x7cf4
jmp 0x7d2e
movq -0x38(%rbp), %rdi
callq 0xa920
movq -0x38(%rbp), %rdi
movl $0xe, %esi
callq 0x7ef0
movq -0x38(%rbp), %rsi
addq $0xa0, %rsi
leaq -0x30(%rbp), %rdi
callq 0x3120
movb $0x1, -0x1(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
jmp 0x7d32
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseObject()
bool parseObject()
    {
        if(accept(TokenType::OBJECT))
        {
            parseString();
            expect(TokenType::STRING);
            std::string name = token;

            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl $0x7, %esi
callq 0x73b0
testb $0x1, %al
jne 0x7d64
jmp 0x7d9e
movq -0x38(%rbp), %rdi
callq 0xa920
movq -0x38(%rbp), %rdi
movl $0xe, %esi
callq 0x7ef0
movq -0x38(%rbp), %rsi
addq $0xa0, %rsi
leaq -0x30(%rbp), %rdi
callq 0x3120
movb $0x1, -0x1(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
jmp 0x7da2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseShade()
bool parseShade()
    {
        if(accept(TokenType::SHADE))
        {
            if(accept(TokenType::NUMBER))
            {
                if(token == "1")
                    smooth = true;
                else
                {
                    error() << "unknown shade type '" << token << "'.";
                }
            }
            else
            {
                expect(TokenType::OFF);
                smooth = false;
            }
            return true;
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x9, %esi
callq 0x73b0
testb $0x1, %al
jne 0x7e47
jmp 0x7ee0
movq -0x18(%rbp), %rdi
movl $0xb, %esi
callq 0x73b0
testb $0x1, %al
jne 0x7e5b
jmp 0x7ec1
movq -0x18(%rbp), %rdi
addq $0xa0, %rdi
leaq 0x780d(%rip), %rsi      # 0xf67a
callq 0xaa40
testb $0x1, %al
jne 0x7e78
jmp 0x7e85
movq -0x18(%rbp), %rax
movb $0x1, 0x98(%rax)
jmp 0x7ebf
movq -0x18(%rbp), %rdi
callq 0xaa70
movq %rax, %rdi
leaq 0x77e4(%rip), %rsi      # 0xf67c
callq 0x3290
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0xa0, %rsi
callq 0x3260
movq %rax, %rdi
leaq 0x77d7(%rip), %rsi      # 0xf691
callq 0x3290
jmp 0x7eda
movq -0x18(%rbp), %rdi
movl $0x11, %esi
callq 0x7ef0
movq -0x18(%rbp), %rax
movb $0x0, 0x98(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x7ee4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::expect(ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::TokenType)
bool expect(TokenType type)
    {
        if(accept(type))
            return true;
        else
        {
            error() << "expected '" <<
                tokenStrings[type] << "' got '" << tokenStrings[token_type] <<
                "'." << std::endl;
        }
        assert(false);
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
callq 0x73b0
testb $0x1, %al
jne 0x7f15
jmp 0x7f1f
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xaa70
movq %rax, %rdi
leaq 0x7779(%rip), %rsi      # 0xf6ab
callq 0x3290
movq %rax, %rdi
movl -0xc(%rbp), %eax
leaq 0xe38c(%rip), %rsi      # 0x162d0
shlq $0x5, %rax
addq %rax, %rsi
callq 0x3260
movq %rax, %rdi
leaq 0x775c(%rip), %rsi      # 0xf6b6
callq 0x3290
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0xe0(%rax), %eax
leaq 0xe35d(%rip), %rsi      # 0x162d0
shlq $0x5, %rax
addq %rax, %rsi
callq 0x3260
movq %rax, %rdi
leaq 0x7708(%rip), %rsi      # 0xf691
callq 0x3290
movq %rax, %rdi
movq 0xe018(%rip), %rsi      # 0x15fb0
callq 0x32e0
leaq 0x771a(%rip), %rdi      # 0xf6be
leaq 0x75dc(%rip), %rsi      # 0xf587
movl $0xe8, %edx
leaq 0x770d(%rip), %rcx      # 0xf6c4
callq 0x31b0
nopl (%rax)
// File: tcannon686[P]obj2webgl/./obj_parser.hpp
// Function: ObjParser<std::basic_ifstream<char, std::char_traits<char>>>::parseString()
void parseString()
    {
        int c;
        std::stringstream s;
        while((c = stream.get()) != '\n' && c != '\r')
        {
            s << (char) c;
        }
        stream.unget();

        token = s.str();
        token_type = TokenType::STRING;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x31e0
movq -0x1d0(%rbp), %rax
movq (%rax), %rdi
callq 0x3350
movl %eax, -0x1d4(%rbp)
jmp 0xa95d
movl -0x1d4(%rbp), %ecx
movl %ecx, -0xc(%rbp)
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x1d5(%rbp)
je 0xa980
cmpl $0xd, -0xc(%rbp)
setne %al
movb %al, -0x1d5(%rbp)
movb -0x1d5(%rbp), %al
testb $0x1, %al
jne 0xa98c
jmp 0xa9c0
leaq -0x188(%rbp), %rdi
movsbl -0xc(%rbp), %esi
callq 0x3340
jmp 0xa99e
jmp 0xa946
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3210
jmp 0xaa32
movq -0x1d0(%rbp), %rax
movq (%rax), %rdi
callq 0x30d0
jmp 0xa9d1
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3280
jmp 0xa9e6
movq -0x1d0(%rbp), %rdi
addq $0xa0, %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x3360
leaq -0x1c8(%rbp), %rdi
callq 0x31a0
movq -0x1d0(%rbp), %rax
movl $0xe, 0xe0(%rax)
leaq -0x198(%rbp), %rdi
callq 0x3210
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x34b0
nop
// File: iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/string_size.cc
// Function: main
int main()
{
    string st("The expense of spirit\n");
    cout << "The size of " << st << "is " << st.size()
         << " characters, including the newline" << endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x10f0
movq -0x48(%rbp), %rdx
leaq 0xd1d(%rip), %rsi       # 0x2004
leaq -0x28(%rbp), %rdi
callq 0x10b0
jmp 0x12f2
leaq -0x29(%rbp), %rdi
callq 0x10a0
movq 0x2cd6(%rip), %rdi      # 0x3fd8
leaq 0xd12(%rip), %rsi       # 0x201b
callq 0x1080
movq %rax, -0x50(%rbp)
jmp 0x1314
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1070
movq %rax, -0x58(%rbp)
jmp 0x1327
movq -0x58(%rbp), %rdi
leaq 0xcf6(%rip), %rsi       # 0x2028
callq 0x1080
movq %rax, -0x60(%rbp)
jmp 0x133d
leaq -0x28(%rbp), %rdi
callq 0x1050
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x1030
movq %rax, -0x68(%rbp)
jmp 0x1358
movq -0x68(%rbp), %rdi
leaq 0xcc9(%rip), %rsi       # 0x202c
callq 0x1080
movq %rax, -0x70(%rbp)
jmp 0x136e
movq -0x70(%rbp), %rdi
movq 0x2c47(%rip), %rsi      # 0x3fc0
callq 0x1090
jmp 0x1380
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1108
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x10a0
jmp 0x13c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1108
movq -0x38(%rbp), %rdi
callq 0x10e0
// File: camargodev[P]n-tile-puzzle/Main.cpp
// Function: processAlgorithm(int, unsigned long)
Result processAlgorithm(int algorithmId, PackedState initialState) {
    switch (algorithmId) {
        case InputReader::BFS_ID:
            return BFS().execute(initialState);
        case InputReader::GREEDY_ID:
            return GreedyBestFirstSearch().execute(initialState);
        case InputReader::ASTAR_ID:
            return AStar().execute(initialState);
        case InputReader::IDFS_ID:
            return IDFS().execute(initialState);
        case InputReader::IDASTAR_ID:
            return IDAStar().execute(initialState);
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movl %esi, 0x64(%rsp)
movq %rdx, 0x58(%rsp)
movl 0x64(%rsp), %eax
movq %rax, 0x28(%rsp)
subq $0x4, %rax
ja 0x39a0
movq 0x28(%rsp), %rax
leaq 0x1574e(%rip), %rcx     # 0x19004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
movq 0x58(%rsp), %rdx
leaq 0x57(%rsp), %rsi
callq 0x122e0
jmp 0x39a2
movq 0x18(%rsp), %rdi
movq 0x58(%rsp), %rdx
leaq 0x56(%rsp), %rsi
callq 0x15560
jmp 0x39a2
movq 0x18(%rsp), %rdi
movq 0x58(%rsp), %rdx
leaq 0x55(%rsp), %rsi
callq 0x171f0
jmp 0x39a2
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x180d0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x18350
jmp 0x392f
leaq 0x48(%rsp), %rdi
callq 0x18110
jmp 0x39a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x18110
jmp 0x39ac
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x18560
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x18980
jmp 0x397a
leaq 0x30(%rsp), %rdi
callq 0x185a0
jmp 0x39a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x185a0
jmp 0x39ac
ud2
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x34a0
nopw %cs:(%rax,%rax)
// File: camargodev[P]n-tile-puzzle/Main.cpp
// Function: currentTime[abi:cxx11]()
string currentTime(){
    time_t     now = time(0);
    struct tm  tstruct;
    char       buf[80];
    tstruct = *localtime(&now);
    strftime(buf, sizeof(buf), "%d-%m-%Y-%H", &tstruct);
    string str(buf);
    for(int i = 0; i < str.length(); i++){
        if(str.at(i) == ':')
            str.at(i) = '_';
    }
    return str;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xe0(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x32b0
movq %rax, 0xd8(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0x3200
movq 0x30(%rax), %rcx
movq %rcx, 0xd0(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movaps %xmm2, 0xc0(%rsp)
movaps %xmm1, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
leaq 0x155e8(%rip), %rdx     # 0x19018
leaq 0x50(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl $0x50, %esi
leaq 0xa0(%rsp), %rcx
callq 0x3240
movb $0x0, 0x4f(%rsp)
leaq 0x4e(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x34b0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x3390
jmp 0x3a76
leaq 0x4e(%rsp), %rdi
callq 0x3310
movl $0x0, 0x38(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x3410
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x3b34
movq 0x20(%rsp), %rdi
movslq 0x38(%rsp), %rsi
callq 0x3500
movq %rax, 0x8(%rsp)
jmp 0x3ac3
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x3b22
movq 0x20(%rsp), %rdi
movslq 0x38(%rsp), %rsi
callq 0x3500
movq %rax, (%rsp)
jmp 0x3ae5
movq (%rsp), %rax
movb $0x5f, (%rax)
jmp 0x3b22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4e(%rsp), %rdi
callq 0x3310
jmp 0x3b57
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x3180
jmp 0x3b57
jmp 0x3b24
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x3a88
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x3b4a
movq 0x20(%rsp), %rdi
callq 0x3180
movq 0x18(%rsp), %rax
addq $0xe8, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x34a0
nopw %cs:(%rax,%rax)
// File: camargodev[P]n-tile-puzzle/src/ManhattanDistance.cpp
// Function: ManhattanDistance::calculate(unsigned long)
int ManhattanDistance :: calculate(PackedState state) {
    int distance = 0;
    uint64_t mask = 15;
    for (int i = 0; i < numberOfTiles*numberOfTiles; i++) {
        uint64_t currentNumber = state & mask;
        currentNumber = currentNumber >> 4*i;
        int intNumber = currentNumber;
        if (intNumber > 0) {
            int expectedPosition = getExpectedPositionForNumber(intNumber);
            int currentDistance = calculateDistanceBeetwenPositions(expectedPosition, i);
            distance += currentDistance;
        }
        mask = mask << 4;
    }
    return distance;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x34(%rsp)
movq $0xf, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq (%rsp), %rdx
movl 0x24(%rsp), %eax
movl (%rdx), %ecx
imull (%rdx), %ecx
cmpl %ecx, %eax
jge 0x556a
movq 0x38(%rsp), %rax
andq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x24(%rsp), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x554c
movq (%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x5580
movq (%rsp), %rdi
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %esi
movl 0x24(%rsp), %edx
callq 0x55a0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl 0x34(%rsp), %eax
movl %eax, 0x34(%rsp)
movq 0x28(%rsp), %rax
shlq $0x4, %rax
movq %rax, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x54d0
movl 0x34(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: camargodev[P]n-tile-puzzle/src/ManhattanDistance.cpp
// Function: ManhattanDistance::calculateDistanceBeetwenPositions(int, int)
int ManhattanDistance :: calculateDistanceBeetwenPositions(int pos1, int pos2) {
    int pos1x = (int) floor(pos1/numberOfTiles);
    int pos1y = pos1 - numberOfTiles*pos1x;

    int pos2x = (int) floor(pos2/numberOfTiles);
    int pos2y = pos2 - numberOfTiles*pos2x;

    int horizontalDistance = abs(pos1x - pos2x);
    int verticalDistance = abs(pos1y - pos2y);

    return horizontalDistance + verticalDistance;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0x2c(%rsp), %eax
cltd
idivl (%rcx)
movl %eax, %edi
callq 0x5670
movq 0x8(%rsp), %rcx
cvttsd2si %xmm0, %eax
movl %eax, 0x24(%rsp)
movl 0x2c(%rsp), %eax
movl (%rcx), %edx
imull 0x24(%rsp), %edx
subl %edx, %eax
movl %eax, 0x20(%rsp)
movl 0x28(%rsp), %eax
cltd
idivl (%rcx)
movl %eax, %edi
callq 0x5670
movq 0x8(%rsp), %rcx
cvttsd2si %xmm0, %eax
movl %eax, 0x1c(%rsp)
movl 0x28(%rsp), %eax
movl (%rcx), %ecx
imull 0x1c(%rsp), %ecx
subl %ecx, %eax
movl %eax, 0x18(%rsp)
movl 0x24(%rsp), %eax
subl 0x1c(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x20(%rsp), %eax
subl 0x18(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::is3TileState(unsigned long)
bool StateManager :: is3TileState(PackedState state) {
    uint64_t mask = INITIAL_MASK;
    uint64_t maskAtPos14 = mask << 4*14;
    uint64_t maskAtPos13 = mask << 4*13;
    uint64_t valAtPos13 = state & maskAtPos13;
    uint64_t valAtPos14 = state & maskAtPos14;
    return valAtPos13 == 0 && valAtPos14 == 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
shlq $0x38, %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
shlq $0x34, %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
andq -0x28(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x10(%rsp), %rax
andq -0x20(%rsp), %rax
movq %rax, -0x38(%rsp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rsp)
movb %al, -0x39(%rsp)
jne 0x573d
cmpq $0x0, -0x38(%rsp)
sete %al
movb %al, -0x39(%rsp)
movb -0x39(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::printUnpackedState(std::vector<std::vector<short, std::allocator<short>>, std::allocator<std::vector<short, std::allocator<short>>>>)
void StateManager :: printUnpackedState(UnpackedState uState) {
    for(int i = 0; i < uState.size(); i++) {
        cout << "\n";
        for(int j = 0; j < uState[i].size(); j++) {
            cout << uState[i][j] << " ";
        }
    }     
}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x4400
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x5882
movq 0x1d7e9(%rip), %rdi     # 0x22fd0
leaq 0x1384b(%rip), %rsi     # 0x19039
callq 0x32e0
movl $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x24(%rsp), %rsi
callq 0x6c60
movq %rax, %rdi
callq 0x4b20
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x5870
movq 0x18(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x6c60
movq %rax, %rdi
movslq 0x20(%rsp), %rsi
callq 0x6c80
movq 0x1d784(%rip), %rdi     # 0x22fd0
movswl (%rax), %esi
callq 0x32a0
movq %rax, %rdi
leaq 0x137d9(%rip), %rsi     # 0x19037
callq 0x32e0
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x57fb
jmp 0x5872
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x57bb
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::pack(std::vector<std::vector<short, std::allocator<short>>, std::allocator<std::vector<short, std::allocator<short>>>>)
PackedState StateManager :: pack(UnpackedState state) {
    PackedState packedState = 0;
    int numberOfTiles = state.size();
    for(int i = 0; i < numberOfTiles; i++) {
        for(int j = 0; j < numberOfTiles; j++) {
            packedState = packedState << 4;
            packedState = packedState|state[i][j];
        }
    }
    return packedState;
}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rax
movq 0x10(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rax, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
callq 0x4400
movl %eax, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x599a
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x598b
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
shlq $0x4, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x28(%rsp), %rsi
callq 0x6c60
movq %rax, %rdi
movslq 0x24(%rsp), %rsi
callq 0x6c80
movq %rax, %rcx
movq 0x8(%rsp), %rax
movswq (%rcx), %rcx
orq %rcx, %rax
movq %rax, 0x30(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x592c
jmp 0x598d
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x591a
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::unpack(unsigned long)
UnpackedState StateManager :: unpack(PackedState state) {
    PackedState mask = INITIAL_MASK;
    UnpackedState unpackedState;
    short numberOfTiles = getNumberOfTiles(state);
    for (int i = 0; i < numberOfTiles; i++) {
        Line line;
        for (int j = 0; j < numberOfTiles; j++) {
            uint64_t value = state & mask;
            value = value >> 4*(numberOfTiles*i+j);
            line.insert(line.begin(), value);
            mask = mask << 4;
        }   
        unpackedState.insert(unpackedState.begin(), line);
    }
    return unpackedState;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0xb8(%rsp)
movb $0x0, 0xb7(%rsp)
callq 0x6ca0
movq 0x30(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0x5690
movl %eax, 0x3c(%rsp)
jmp 0x5a1a
movl 0x3c(%rsp), %eax
movw %ax, 0xb4(%rsp)
movl $0x0, 0xa0(%rsp)
movl 0xa0(%rsp), %eax
movswl 0xb4(%rsp), %ecx
cmpl %ecx, %eax
jge 0x5be1
leaq 0x88(%rsp), %rdi
callq 0x6cb0
movl $0x0, 0x84(%rsp)
movl 0x84(%rsp), %eax
movswl 0xb4(%rsp), %ecx
cmpl %ecx, %eax
jge 0x5b78
movq 0xc0(%rsp), %rax
movq 0xb8(%rsp), %rcx
andq %rcx, %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movzwl 0xb4(%rsp), %ecx
movl 0xa0(%rsp), %edx
imull %edx, %ecx
movl 0x84(%rsp), %edx
addl %edx, %ecx
shlb $0x2, %cl
shrq %cl, %rax
movq %rax, 0x78(%rsp)
leaq 0x88(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x6d00
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x6d30
movq 0x10(%rsp), %rdi
movw 0x78(%rsp), %ax
movw %ax, 0x66(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x66(%rsp), %rdx
callq 0x6cc0
movq %rax, 0x18(%rsp)
jmp 0x5b05
movq 0x18(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0xb8(%rsp), %rax
shlq $0x4, %rax
movq %rax, 0xb8(%rsp)
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x5a60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x5c0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x52e0
jmp 0x5c0a
movq 0x20(%rsp), %rdi
callq 0x6fa0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x6fd0
movq 0x20(%rsp), %rdi
movq 0x50(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0x6d70
movq %rax, 0x8(%rsp)
jmp 0x5bb4
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x52e0
movl 0xa0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa0(%rsp)
jmp 0x5a31
movb $0x1, 0xb7(%rsp)
testb $0x1, 0xb7(%rsp)
jne 0x5bfd
movq 0x20(%rsp), %rdi
callq 0x40f0
movq 0x28(%rsp), %rax
addq $0xd8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x40f0
movq 0xa8(%rsp), %rdi
callq 0x34a0
nopw %cs:(%rax,%rax)
// File: camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::produceNextStates(State)
vector<State> StateManager :: produceNextStates(State state) {
    vector<State> neighbors;
    int blankPosition = getBlankTilePosition(state.value);
    short numberOfTiles = getNumberOfTiles(state.value);
    for (auto neighboorPosition : getNeighborsPositionsAndHeuristics(state)) {
        State newState;
        newState.value = swapValuesByPositions(state.value, blankPosition, neighboorPosition.first);
        newState.heuristic = neighboorPosition.second;
        newState.parentBlankPos = blankPosition;
        neighbors.insert(neighbors.begin(), newState);
    }
    return neighbors;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xd8(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x30(%rsp)
movb $0x0, 0xc7(%rsp)
callq 0x7010
movq 0x30(%rsp), %rdi
movq 0xd0(%rsp), %rsi
callq 0x5e80
movl %eax, 0x3c(%rsp)
jmp 0x5c96
movq 0x30(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, 0xc0(%rsp)
movq 0xd0(%rsp), %rsi
callq 0x5690
movl %eax, 0x1c(%rsp)
jmp 0x5cb9
movq 0x30(%rsp), %rsi
movl 0x1c(%rsp), %eax
movw %ax, 0xb2(%rsp)
movups 0xd0(%rsp), %xmm0
movaps %xmm0, 0x80(%rsp)
movq 0x80(%rsp), %rdx
movq 0x88(%rsp), %rcx
leaq 0x90(%rsp), %rdi
callq 0x5f30
jmp 0x5cf9
leaq 0x90(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x7020
movq %rax, 0x78(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x7050
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x7080
testb $0x1, %al
jne 0x5d6b
leaq 0x90(%rsp), %rdi
callq 0x7380
jmp 0x5e33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x5e5c
leaq 0x78(%rsp), %rdi
callq 0x70c0
movq 0x30(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x68(%rsp)
movq 0xd0(%rsp), %rsi
movl 0xc0(%rsp), %edx
movl 0x68(%rsp), %ecx
callq 0x6460
movq %rax, 0x10(%rsp)
jmp 0x5da1
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
movb 0x6c(%rsp), %al
movb %al, 0x60(%rsp)
movb 0xc0(%rsp), %al
movb %al, 0x61(%rsp)
callq 0x72f0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x7320
movq 0x20(%rsp), %rdi
movq 0x50(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x70d0
movq %rax, 0x8(%rsp)
jmp 0x5df7
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x7360
jmp 0x5d2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x7380
jmp 0x5e5c
movb $0x1, 0xc7(%rsp)
testb $0x1, 0xc7(%rsp)
jne 0x5e4f
movq 0x20(%rsp), %rdi
callq 0x73e0
movq 0x28(%rsp), %rax
addq $0xe8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x73e0
movq 0xb8(%rsp), %rdi
callq 0x34a0
nopw %cs:(%rax,%rax)
// File: camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::getBlankTilePosition(unsigned long)
int StateManager :: getBlankTilePosition(PackedState state) {
    PackedState mask = INITIAL_MASK;
    short numberOfTiles = getNumberOfTiles(state);
    for (int i = 0; i < numberOfTiles*numberOfTiles; i++) {
        uint64_t value = state & mask;
        short shortValue = value >> 4*i;
        if (shortValue == BLANK)
            return i;
        mask = mask << 4;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rsi
callq 0x5690
movw %ax, 0x1e(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movswl 0x1e(%rsp), %ecx
movswl 0x1e(%rsp), %edx
imull %edx, %ecx
cmpl %ecx, %eax
jge 0x5f25
movq 0x28(%rsp), %rax
andq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x18(%rsp), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq (%rsp), %rcx
movw %ax, 0xe(%rsp)
movswl 0xe(%rsp), %eax
movswl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x5f0a
movl 0x18(%rsp), %eax
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rax
shlq $0x4, %rax
movq %rax, 0x20(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x5eb7
ud2
nopw (%rax,%rax)
// File: camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::swapValuesByPositions(unsigned long, int, int)
PackedState StateManager :: swapValuesByPositions(PackedState state, int blankPosition, int neighborPosition) {
    
    uint64_t maskToGetNeighborValue = INITIAL_MASK;
    maskToGetNeighborValue = maskToGetNeighborValue << 4*neighborPosition;
    uint64_t neighborValue = state & maskToGetNeighborValue;
    
    // cleans neighbor position
    uint64_t maskToCleanNeighborPosition = ~maskToGetNeighborValue;
    uint64_t stateWithBlankNeighbor = state & maskToCleanNeighborPosition;
    
    // moves neighbor value to blank position
    if (neighborPosition < blankPosition)
        neighborValue = neighborValue << 4*(blankPosition-neighborPosition);
    else
        neighborValue = neighborValue >> 4*(neighborPosition-blankPosition);

    return stateWithBlankNeighbor | neighborValue;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movl -0x18(%rsp), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
andq -0x20(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
xorq $-0x1, %rax
movq %rax, -0x30(%rsp)
movq -0x10(%rsp), %rax
andq -0x30(%rsp), %rax
movq %rax, -0x38(%rsp)
movl -0x18(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x64e8
movq -0x28(%rsp), %rax
movl -0x14(%rsp), %ecx
subl -0x18(%rsp), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x28(%rsp)
jmp 0x6502
movq -0x28(%rsp), %rax
movl -0x18(%rsp), %ecx
subl -0x14(%rsp), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, -0x28(%rsp)
movq -0x38(%rsp), %rax
orq -0x28(%rsp), %rax
retq
nopl (%rax)
// File: camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::produceNextPackedStates(unsigned long)
vector<PackedState> StateManager :: produceNextPackedStates(PackedState state) {
    vector<PackedState> neighbors;
    int blankPosition = getBlankTilePosition(state);
    short numberOfTiles = getNumberOfTiles(state);
    vector<int> neighborsPositions = getNeighborsPositions(numberOfTiles, blankPosition);
    for (auto neighboorPosition : neighborsPositions) {
        PackedState neighbor = swapValuesByPositions(state, blankPosition, neighboorPosition);
        neighbors.insert(neighbors.begin(), neighbor);
    }
    return neighbors;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x30(%rsp)
movb $0x0, 0xaf(%rsp)
callq 0x7440
movq 0x30(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x5e80
movl %eax, 0x3c(%rsp)
jmp 0x656e
movq 0x30(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, 0xa8(%rsp)
movq 0xb0(%rsp), %rsi
callq 0x5690
movl %eax, 0x1c(%rsp)
jmp 0x6591
movq 0x30(%rsp), %rsi
movl 0x1c(%rsp), %eax
movw %ax, 0x9a(%rsp)
movswl 0x9a(%rsp), %edx
movl 0xa8(%rsp), %ecx
leaq 0x80(%rsp), %rdi
callq 0x6720
jmp 0x65c0
leaq 0x80(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x7450
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x7480
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x74b0
testb $0x1, %al
jne 0x6603
jmp 0x66cc
leaq 0x70(%rsp), %rdi
callq 0x74f0
movq 0x30(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x64(%rsp)
movq 0xb0(%rsp), %rsi
movl 0xa8(%rsp), %edx
movl 0x64(%rsp), %ecx
callq 0x6460
movq %rax, 0x10(%rsp)
jmp 0x6637
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
callq 0x7720
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x7750
movq 0x20(%rsp), %rdi
movq 0x50(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x7500
movq %rax, 0x8(%rsp)
jmp 0x667a
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x7790
jmp 0x65eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x6702
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x77b0
jmp 0x6702
movb $0x1, 0xaf(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x77b0
testb $0x1, 0xaf(%rsp)
jne 0x66f5
movq 0x20(%rsp), %rdi
callq 0x7810
movq 0x28(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x7810
movq 0xa0(%rsp), %rdi
callq 0x34a0
nopl (%rax)
// File: camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::getNeighborsPositions(short, int)
vector<int> StateManager :: getNeighborsPositions(short numberOfTiles, int blankPosition) {
    vector<int> neighbors;
    if (blankPosition < numberOfTiles*(numberOfTiles-1))
        neighbors.insert(neighbors.begin(), blankPosition+numberOfTiles);
    if ((blankPosition+1) % numberOfTiles != 0)
        neighbors.insert(neighbors.begin(), blankPosition+1);
    if (blankPosition % numberOfTiles != 0)
        neighbors.insert(neighbors.begin(), blankPosition-1);
    if (blankPosition > numberOfTiles-1)
        neighbors.insert(neighbors.begin(), blankPosition-numberOfTiles);
    return neighbors;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0x28(%rsp)
movw %dx, %ax
movq %rdi, %rdx
movq %rdx, 0x30(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movw %ax, 0xd6(%rsp)
movl %ecx, 0xd0(%rsp)
movb $0x0, 0xcf(%rsp)
callq 0x7870
movl 0xd0(%rsp), %eax
movswl 0xd6(%rsp), %ecx
movswl 0xd6(%rsp), %edx
subl $0x1, %edx
imull %edx, %ecx
cmpl %ecx, %eax
jge 0x681a
movq 0x28(%rsp), %rdi
callq 0x7450
movq %rax, 0xb8(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x78c0
movq 0x28(%rsp), %rdi
movl 0xd0(%rsp), %eax
movswl 0xd6(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0xb4(%rsp)
movq 0xc0(%rsp), %rsi
leaq 0xb4(%rsp), %rdx
callq 0x7880
movq %rax, 0x20(%rsp)
jmp 0x67e8
movq 0x20(%rsp), %rax
movq %rax, 0x98(%rsp)
jmp 0x681a
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
callq 0x77b0
jmp 0x6994
movl 0xd0(%rsp), %eax
addl $0x1, %eax
movswl 0xd6(%rsp), %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x6896
movq 0x28(%rsp), %rdi
callq 0x7450
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x78c0
movq 0x28(%rsp), %rdi
movl 0xd0(%rsp), %eax
incl %eax
movl %eax, 0x84(%rsp)
movq 0x90(%rsp), %rsi
leaq 0x84(%rsp), %rdx
callq 0x7880
movq %rax, 0x18(%rsp)
jmp 0x688c
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
movl 0xd0(%rsp), %eax
movswl 0xd6(%rsp), %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x68fd
movq 0x28(%rsp), %rdi
callq 0x7450
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x78c0
movq 0x28(%rsp), %rdi
movl 0xd0(%rsp), %eax
decl %eax
movl %eax, 0x64(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x64(%rsp), %rdx
callq 0x7880
movq %rax, 0x10(%rsp)
jmp 0x68f3
movq 0x10(%rsp), %rax
movq %rax, 0x58(%rsp)
movl 0xd0(%rsp), %eax
movswl 0xd6(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x696b
movq 0x28(%rsp), %rdi
callq 0x7450
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x78c0
movq 0x28(%rsp), %rdi
movl 0xd0(%rsp), %eax
movswl 0xd6(%rsp), %ecx
subl %ecx, %eax
movl %eax, 0x44(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x44(%rsp), %rdx
callq 0x7880
movq %rax, 0x8(%rsp)
jmp 0x6961
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movb $0x1, 0xcf(%rsp)
testb $0x1, 0xcf(%rsp)
jne 0x6987
movq 0x28(%rsp), %rdi
callq 0x77b0
movq 0x30(%rsp), %rax
addq $0xe8, %rsp
retq
movq 0xa8(%rsp), %rdi
callq 0x34a0
nopw %cs:(%rax,%rax)
// File: camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: getValueAtPosition(unsigned long, int)
int getValueAtPosition(PackedState state, int position) {
    uint64_t maskToGetNeighborValue = 15;
    maskToGetNeighborValue = maskToGetNeighborValue << 4*position;
    uint64_t neighborValue = state & maskToGetNeighborValue;
    neighborValue = neighborValue >> 4*(position);
    return (int) neighborValue;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq $0xf, -0x18(%rsp)
movq -0x18(%rsp), %rax
movl -0xc(%rsp), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
andq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movl -0xc(%rsp), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: camargodev[P]n-tile-puzzle/src/StateManager.cpp
// Function: StateManager::calculateNeighborHeuristic(State, int, int)
int StateManager :: calculateNeighborHeuristic(State state, int blankPosition, int newPosition) {
    int valAtNewPosition = getValueAtPosition(state.value, newPosition);
    int expectedPosition = heuristicCalculator.getExpectedPositionForNumber(valAtNewPosition);
    int diffToSubtract = heuristicCalculator.calculateDistanceBeetwenPositions(newPosition, expectedPosition);
    int diffToAdd = heuristicCalculator.calculateDistanceBeetwenPositions(blankPosition, expectedPosition);
    return state.heuristic - diffToSubtract + diffToAdd;
}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x69b0
movq (%rsp), %rdi
movl %eax, 0x14(%rsp)
addq $0x10, %rdi
movl 0x14(%rsp), %esi
callq 0x5580
movq (%rsp), %rdi
movl %eax, 0x10(%rsp)
addq $0x10, %rdi
movl 0x18(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x55a0
movq (%rsp), %rdi
movl %eax, 0xc(%rsp)
addq $0x10, %rdi
movl 0x1c(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x55a0
movl %eax, 0x8(%rsp)
movzbl 0x30(%rsp), %eax
subl 0xc(%rsp), %eax
addl 0x8(%rsp), %eax
addq $0x38, %rsp
retq