LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: miklhh[P]tetris/src/game.cpp
// Function: rotate_block_matrix(block_t*, bool, int)
static void rotate_block_matrix(block_t* block, bool counter_clockwise, int matrix_size)
{
    /* Create a new block structure and initialize it to EMPTY. */
    block_struct_t rotated_block_structure;
    for (int y = 0; y < MAX_BLOCK_HEIGHT; y++)
    {
        for (int x = 0; x < MAX_BLOCK_WIDTH; x++)
        {
            rotated_block_structure.tile[y][x] = EMPTY;
        }
    }
	
	if (counter_clockwise) 
	{
		/* Counter closewise rotation. */
		for (int y = 0; y < (matrix_size); y++)
		{
			for (int x = 0; x < (matrix_size); x++)
			{
				rotated_block_structure.tile[(matrix_size-1) - x][y] = block->structure.tile[y][x];
			}
		}
	}
	else
	{
		/* Clockwise rotation. */
		for (int y = 0; y < (matrix_size); y++)
		{
			for (int x = 0; x < (matrix_size); x++)
			{
				rotated_block_structure.tile[x][(matrix_size-1) - y] = block->structure.tile[y][x];
			}
		}
	}

	/* Give the rotated structure to the block. */
	block->structure = rotated_block_structure;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x54(%rbp)
cmpl $0x4, -0x54(%rbp)
jge 0x2d63
movl $0x0, -0x58(%rbp)
cmpl $0x4, -0x58(%rbp)
jge 0x2d56
leaq -0x50(%rbp), %rax
movslq -0x54(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x58(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x2d2b
jmp 0x2d58
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x2d1e
testb $0x1, -0x9(%rbp)
je 0x2dd9
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2dd7
movl $0x0, -0x60(%rbp)
movl -0x60(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2dca
movq -0x8(%rbp), %rax
addq $0x10, %rax
movslq -0x5c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x60(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq -0x50(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
subl -0x60(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x5c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x2d7f
jmp 0x2dcc
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x2d70
jmp 0x2e49
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2e47
movl $0x0, -0x68(%rbp)
movl -0x68(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x2e3a
movq -0x8(%rbp), %rax
addq $0x10, %rax
movslq -0x64(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x68(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq -0x50(%rbp), %rax
movslq -0x68(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
subl -0x64(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x2def
jmp 0x2e3c
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x2de0
jmp 0x2e49
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq -0x50(%rbp), %rsi
movl $0x40, %edx
callq 0x2130
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: miklhh[P]tetris/src/game.cpp
// Function: remove_row(int)
void remove_row(int row)
{
    for (int x = 0; x < GRID_WIDTH; x++)
    {
        field[row][x].tile     = EMPTY;
        field[row][x].color_f  = COLOR_BACKGROUND_FORTH;
        field[row][x].color_b  = COLOR_BACKGROUND_BACK;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0xa, -0x8(%rbp)
jge 0x335a
movslq -0x4(%rbp), %rcx
leaq 0x4e81(%rip), %rax      # 0x8170
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movslq -0x4(%rbp), %rcx
leaq 0x4e5d(%rip), %rax      # 0x8170
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x7, (%rax)
movslq -0x4(%rbp), %rcx
leaq 0x4e3a(%rip), %rax      # 0x8170
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x6, 0x4(%rax)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x32de
popq %rbp
retq
nopl (%rax)
// File: miklhh[P]tetris/src/game.cpp
// Function: move_field_down(int, int)
void move_field_down(int row, int n)
{
    for (int y = row - 1; y >= 0; y--)
    {
        for (int x = 0; x < GRID_WIDTH; x++)
        {
            field[y + n][x].tile = field[y][x].tile;
            field[y + n][x].color_f = field[y][x].color_f;
            field[y + n][x].color_b = field[y][x].color_b;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x3479
movl $0x0, -0x10(%rbp)
cmpl $0xa, -0x10(%rbp)
jge 0x3469
movslq -0xc(%rbp), %rcx
leaq 0x4dd7(%rip), %rax      # 0x8170
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movl -0xc(%rbp), %eax
addl -0x8(%rbp), %eax
movslq %eax, %rdx
leaq 0x4db2(%rip), %rax      # 0x8170
imulq $0x78, %rdx, %rdx
addq %rdx, %rax
movslq -0x10(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x4d92(%rip), %rax      # 0x8170
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
movl -0xc(%rbp), %eax
addl -0x8(%rbp), %eax
movslq %eax, %rdx
leaq 0x4d6e(%rip), %rax      # 0x8170
imulq $0x78, %rdx, %rdx
addq %rdx, %rax
movslq -0x10(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movslq -0xc(%rbp), %rcx
leaq 0x4d4f(%rip), %rax      # 0x8170
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
movl -0xc(%rbp), %eax
addl -0x8(%rbp), %eax
movslq %eax, %rdx
leaq 0x4d2a(%rip), %rax      # 0x8170
imulq $0x78, %rdx, %rdx
addq %rdx, %rax
movslq -0x10(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3384
jmp 0x346b
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3373
popq %rbp
retq
nopl (%rax,%rax)
// File: miklhh[P]tetris/src/game.cpp
// Function: test_row_full(int)
bool test_row_full(int row)
{
    bool res = true;
    for (int x = 0; x < GRID_WIDTH; x++)
    {
        if (field[row][x].tile == EMPTY)
        {
            res = false;
            break;
        }
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movb $0x1, -0x5(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x34ce
movslq -0x4(%rbp), %rcx
leaq 0x4ccd(%rip), %rax      # 0x8170
imulq $0x78, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0x34c1
movb $0x0, -0x5(%rbp)
jmp 0x34ce
jmp 0x34c3
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3492
movb -0x5(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: miklhh[P]tetris/src/game.cpp
// Function: game_draw_field()
void game_draw_field()
{
    extern SDL_Renderer* renderer;
    extern int block_width;
    extern int block_height;
    for (int y = 0; y < GRID_HEIGHT; y++)
    {
        for (int x = 0; x < GRID_WIDTH; x++)
        {
            draw_box(
                x * block_width, y * block_height,  // Position.
                block_width, block_height,          // Size.
                field[y][x].color_f,                // Foreground color.
                field[y][x].color_b,                // Background color.
                renderer,                           // Renderer to draw to.
                GLOBAL_MARGIN                       // Margin level (px).
            );
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x14, -0x4(%rbp)
jge 0x35e0
movl $0x0, -0x8(%rbp)
cmpl $0xa, -0x8(%rbp)
jge 0x35d0
movl -0x8(%rbp), %edi
leaq 0x5644(%rip), %rax      # 0x8b88
imull (%rax), %edi
movl -0x4(%rbp), %esi
leaq 0x563b(%rip), %rax      # 0x8b8c
imull (%rax), %esi
leaq 0x562d(%rip), %rax      # 0x8b88
movl (%rax), %edx
leaq 0x5628(%rip), %rax      # 0x8b8c
movl (%rax), %ecx
movslq -0x4(%rbp), %r8
leaq 0x4bff(%rip), %rax      # 0x8170
imulq $0x78, %r8, %r8
addq %r8, %rax
movslq -0x8(%rbp), %r8
imulq $0xc, %r8, %r8
addq %r8, %rax
movl (%rax), %r8d
movslq -0x4(%rbp), %r9
leaq 0x4bdf(%rip), %rax      # 0x8170
imulq $0x78, %r9, %r9
addq %r9, %rax
movslq -0x8(%rbp), %r9
imulq $0xc, %r9, %r9
addq %r9, %rax
movl 0x4(%rax), %r9d
leaq 0x55ca(%rip), %rax      # 0x8b78
movq (%rax), %rax
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x2460
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3530
jmp 0x35d2
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x351f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: miklhh[P]tetris/src/game.cpp
// Function: iteration_timer()
bool iteration_timer()
{
    using namespace std::chrono;
    static time_point<high_resolution_clock>  last_timestamp;
    time_point<high_resolution_clock>         current_timestamp         = high_resolution_clock::now();
    milliseconds                              time_since_last_call      = duration_cast<milliseconds>(current_timestamp - last_timestamp);

    if (current_iteration_wait_time_ms < time_since_last_call.count())
    {
        last_timestamp = current_timestamp;
        return true;
    }
    else return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x2060
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
leaq 0x51ec(%rip), %rsi      # 0x8ae8
callq 0x3c30
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3c00
movq %rax, -0x18(%rbp)
movslq 0x51d7(%rip), %rax      # 0x8af0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3c80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jge 0x3943
movq -0x10(%rbp), %rax
movq %rax, 0x51ab(%rip)      # 0x8ae8
movb $0x1, -0x1(%rbp)
jmp 0x3947
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: miklhh[P]tetris/src/get_window_size.cpp
// Function: get_window_height(SDL_DisplayMode)
int get_window_height(SDL_DisplayMode display_mode)
{
	bool height_limiting = false;
	if (display_mode.w > display_mode.h)
		height_limiting = true;

	if (height_limiting)
	{
		/* Must be a multiple of 50. */
		return (display_mode.h / 20 - SCALE_FACTOR) * 20;
	}
	else
	{
		/* Must be a multiple of 50. */
		return (display_mode.w / 20 - SCALE_FACTOR) * 20;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, -0x5(%rbp)
movl 0x4(%rcx), %eax
cmpl 0x8(%rcx), %eax
jle 0x3dec
movb $0x1, -0x5(%rbp)
testb $0x1, -0x5(%rbp)
je 0x3e0c
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x14, %ecx
cltd
idivl %ecx
subl $0x5, %eax
imull $0x14, %eax, %eax
movl %eax, -0x4(%rbp)
jmp 0x3e24
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl $0x14, %ecx
cltd
idivl %ecx
subl $0x5, %eax
imull $0x14, %eax, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: miklhh[P]tetris/src/get_window_size.cpp
// Function: get_window_width(SDL_DisplayMode)
int get_window_width(SDL_DisplayMode display_mode)
{
	bool height_limiting = false;
	if (display_mode.w > display_mode.h)
		height_limiting = true;

	if (height_limiting)
	{
		return (display_mode.h / 20 - SCALE_FACTOR) * 20;
	}
	else
	{
		return (display_mode.w / 20 - SCALE_FACTOR) * 20;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, -0x5(%rbp)
movl 0x4(%rcx), %eax
cmpl 0x8(%rcx), %eax
jle 0x3e4c
movb $0x1, -0x5(%rbp)
testb $0x1, -0x5(%rbp)
je 0x3e6c
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x14, %ecx
cltd
idivl %ecx
subl $0x5, %eax
imull $0x14, %eax, %eax
movl %eax, -0x4(%rbp)
jmp 0x3e84
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl $0x14, %ecx
cltd
idivl %ecx
subl $0x5, %eax
imull $0x14, %eax, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: miklhh[P]tetris/src/input.cpp
// Function: handle_event(SDL_Event*)
void handle_event(SDL_Event* evnt)
{
    static bool rotate_clockwise_released          = true;
    static bool rotate_counter_clockwise_released  = true;

    switch (evnt->type)
    {
    case SDL_KEYDOWN:
        switch (evnt->key.keysym.sym)
        {
        case KEY_SOFT_DROP:
            set_temp_iteration_timer(50);
            break;

        case KEY_ROTATE_COUNTER_CLOCKWISE:
            if (rotate_counter_clockwise_released)
            {
                rotate_counter_clockwise_released = false;
                current_block_rotate(COUNTER_CLOCKWISE);
            }
            break;

        case KEY_ROTATE_CLOCKWISE:
            if (rotate_clockwise_released)
            {
                rotate_clockwise_released = false;
                current_block_rotate(CLOCKWISE);
            }
            break;

        default:
            break;
        }
        break;

    case SDL_KEYUP:
        switch (evnt->key.keysym.sym)
        {
        case KEY_SOFT_DROP:
            set_iteration_timer(CURRENT_LEVEL_TIME_MS);
            break;

        case KEY_ROTATE_COUNTER_CLOCKWISE:
            rotate_counter_clockwise_released = true;
            break;

        case KEY_ROTATE_CLOCKWISE:
            rotate_clockwise_released = true;
            break;

        default:
            break;
        }
        break;

    default:
        break;

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x300, %eax            # imm = 0x300
je 0x3ebd
jmp 0x3eae
movl -0xc(%rbp), %eax
subl $0x301, %eax            # imm = 0x301
je 0x3f29
jmp 0x3f6f
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x78, %eax
je 0x3f0c
jmp 0x3ece
movl -0x10(%rbp), %eax
subl $0x7a, %eax
je 0x3ef0
jmp 0x3ed8
movl -0x10(%rbp), %eax
subl $0x40000051, %eax       # imm = 0x40000051
jne 0x3f25
jmp 0x3ee4
movl $0x32, %edi
callq 0x3960
jmp 0x3f27
testb $0x1, 0x424a(%rip)      # 0x8141
je 0x3f0a
movb $0x0, 0x4241(%rip)      # 0x8141
movl $0x1, %edi
callq 0x39c0
jmp 0x3f27
testb $0x1, 0x422d(%rip)      # 0x8140
je 0x3f23
movb $0x0, 0x4224(%rip)      # 0x8140
xorl %edi, %edi
callq 0x39c0
jmp 0x3f27
jmp 0x3f27
jmp 0x3f71
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x78, %eax
je 0x3f62
jmp 0x3f3a
movl -0x14(%rbp), %eax
subl $0x7a, %eax
je 0x3f59
jmp 0x3f44
movl -0x14(%rbp), %eax
subl $0x40000051, %eax       # imm = 0x40000051
jne 0x3f6b
jmp 0x3f50
xorl %edi, %edi
callq 0x2b50
jmp 0x3f6d
movb $0x1, 0x41e1(%rip)      # 0x8141
jmp 0x3f6d
movb $0x1, 0x41d7(%rip)      # 0x8140
jmp 0x3f6d
jmp 0x3f6d
jmp 0x3f71
jmp 0x3f71
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: miklhh[P]tetris/src/input.cpp
// Function: handle_keyboard_input(unsigned char const*)
void handle_keyboard_input(keyboard_state_t* keyboard_state)
{
    if (keyboard_key_timer(SDL_SCANCODE_LEFT, keyboard_state))
        current_block_move(DIRECTION_LEFT);

    if (keyboard_key_timer(SDL_SCANCODE_RIGHT, keyboard_state))
        current_block_move(DIRECTION_RIGHT);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x50, %edi
callq 0x3fd0
testb $0x1, %al
jne 0x3fa0
jmp 0x3fa7
xorl %edi, %edi
callq 0x3980
movq -0x8(%rbp), %rsi
movl $0x4f, %edi
callq 0x3fd0
testb $0x1, %al
jne 0x3fbb
jmp 0x3fc5
movl $0x1, %edi
callq 0x3980
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/hobbesSolver.cc
// Function: HobbesSolver::HobbesSolver()
HobbesSolver::HobbesSolver() {
	invertedList = NULL;
	defaultInvertedList = NULL;
	dynamicMatrix = NULL;
	defaultDynamicMatrix = NULL;
	readLength = 0;
	seedNum = 0;
	seedLength = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0xa, %esi
movl $0x1e, %edx
callq 0x7110
movq 0x8(%rsp), %rax
movq $0x0, 0x358(%rax)
movq $0x0, 0x378(%rax)
movq $0x0, 0x360(%rax)
movq $0x0, 0x380(%rax)
movl $0x0, 0x368(%rax)
movl $0x0, 0x36c(%rax)
movl $0x0, 0x370(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/hobbesSolver.cc
// Function: HobbesSolver::~HobbesSolver()
HobbesSolver::~HobbesSolver() {
	if  (invertedList != NULL) {
		delete [] invertedList;
		invertedList = NULL;
	}
	if  (defaultInvertedList != NULL) {
		delete [] defaultInvertedList;
		defaultInvertedList = NULL;
	}
		if  (dynamicMatrix != NULL) {
		delete [] dynamicMatrix;
		dynamicMatrix = NULL;
	}
	if  (defaultDynamicMatrix != NULL) {
		delete [] defaultDynamicMatrix;
		defaultDynamicMatrix = NULL;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x358(%rax)
je 0x5f3e
movq 0x28(%rsp), %rax
movq 0x358(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x5f2e
movq 0x20(%rsp), %rdi
callq 0x33f0
movq 0x28(%rsp), %rax
movq $0x0, 0x358(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x378(%rax)
je 0x5f7e
movq 0x28(%rsp), %rax
movq 0x378(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x5f6e
movq 0x18(%rsp), %rdi
callq 0x33f0
movq 0x28(%rsp), %rax
movq $0x0, 0x378(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x360(%rax)
je 0x5fbe
movq 0x28(%rsp), %rax
movq 0x360(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x5fae
movq 0x10(%rsp), %rdi
callq 0x33f0
movq 0x28(%rsp), %rax
movq $0x0, 0x360(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x380(%rax)
je 0x5ffe
movq 0x28(%rsp), %rax
movq 0x380(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x5fee
movq 0x8(%rsp), %rdi
callq 0x33f0
movq 0x28(%rsp), %rax
movq $0x0, 0x380(%rax)
movq 0x28(%rsp), %rdi
callq 0x72c0
addq $0x38, %rsp
retq
nopl (%rax)
// File: c2-d2[P]disty/src/main.cpp
// Function: void compute_consensus<std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>>(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void compute_consensus(const T &pileup, string &consensus) {
    assert(pileup.size()==consensus.size());
    assert(pileup[0].size()==128);

    for(int i=0; i<static_cast<int>(pileup.size()); i++){
        char c='N';
        int max_freq=-1;
        const auto &column=pileup[i];

        for(int d=0;d<128;d++){
            if(d!='N'){
                if(column[d]>max_freq){
                    max_freq=column[d];
                    c=(char)d;
                }
            }
        }

        consensus[i]=c;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7b40
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2140
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x49c4
jmp 0x49e3
leaq 0x3f3e(%rip), %rdi      # 0x8909
leaq 0x3bfc(%rip), %rsi      # 0x85ce
movl $0x13f, %edx            # imm = 0x13F
leaq 0x3f4b(%rip), %rcx      # 0x8929
callq 0x2110
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7c80
movq %rax, %rdi
callq 0x7610
cmpq $0x80, %rax
jne 0x4a02
jmp 0x4a21
leaq 0x3eea(%rip), %rdi      # 0x88f3
leaq 0x3bbe(%rip), %rsi      # 0x85ce
movl $0x140, %edx            # imm = 0x140
leaq 0x3f0d(%rip), %rcx      # 0x8929
callq 0x2110
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7b40
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x4ad8
movb $0x4e, -0x15(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x7c80
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x80, -0x2c(%rbp)
jge 0x4ab2
cmpl $0x4e, -0x2c(%rbp)
je 0x4aa5
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x7ca0
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jle 0x4aa3
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x7ca0
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x2c(%rbp), %eax
movb %al, -0x15(%rbp)
jmp 0x4aa5
jmp 0x4aa7
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4a68
movb -0x15(%rbp), %al
movb %al, -0x3d(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x23d0
movb -0x3d(%rbp), %cl
movb %cl, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4a28
addq $0x40, %rsp
popq %rbp
retq
nop
// File: c2-d2[P]disty/src/main.cpp
// Function: void pair_matrix_char_binary<std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>>(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, pair_char_t&)
void pair_matrix_char_binary(T &pair_matrix, pair_char_t &pair_char) {
    assert(pair_matrix.size()==128);
    assert(pair_matrix[0].size()==128);

    pair_char.matches=0;
    pair_char.mismatches=0;
    pair_char.unknown=0;

    for(unsigned char i=0;i<128;i++){
        char n1_nt4=binary_nt256_nt4[i];
        for(unsigned char j=0;j<128;j++){
            char n2_nt4=binary_nt256_nt4[j];

            if (n1_nt4==2 || n2_nt4==2){
                pair_char.unknown++;
            }
            else{
                if(n1_nt4+n2_nt4==1)
                {
                    pair_char.matches++;
                }
                else {
                    pair_char.mismatches++;
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7b40
cmpq $0x80, %rax
jne 0x5273
jmp 0x5292
leaq 0x3864(%rip), %rdi      # 0x8ade
leaq 0x334d(%rip), %rsi      # 0x85ce
movl $0x1c1, %edx            # imm = 0x1C1
leaq 0x38d7(%rip), %rcx      # 0x8b64
callq 0x2110
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x53b0
movq %rax, %rdi
callq 0x7610
cmpq $0x80, %rax
jne 0x52b1
jmp 0x52d0
leaq 0x383e(%rip), %rdi      # 0x8af6
leaq 0x330f(%rip), %rsi      # 0x85ce
movl $0x1c2, %edx            # imm = 0x1C2
leaq 0x3899(%rip), %rcx      # 0x8b64
callq 0x2110
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movb $0x0, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x80, %eax
jge 0x539f
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x2ee0(%rip), %rax      # 0x81f0
movb (%rax,%rcx), %al
movb %al, -0x12(%rbp)
movb $0x0, -0x13(%rbp)
movzbl -0x13(%rbp), %eax
cmpl $0x80, %eax
jge 0x5390
movzbl -0x13(%rbp), %eax
movl %eax, %ecx
leaq 0x2ebe(%rip), %rax      # 0x81f0
movb (%rax,%rcx), %al
movb %al, -0x14(%rbp)
movsbl -0x12(%rbp), %eax
cmpl $0x2, %eax
je 0x534a
movsbl -0x14(%rbp), %eax
cmpl $0x2, %eax
jne 0x5359
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x5384
movsbl -0x12(%rbp), %eax
movsbl -0x14(%rbp), %ecx
addl %ecx, %eax
cmpl $0x1, %eax
jne 0x5375
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x5382
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x5384
jmp 0x5386
movb -0x13(%rbp), %al
addb $0x1, %al
movb %al, -0x13(%rbp)
jmp 0x531a
jmp 0x5392
movb -0x11(%rbp), %al
addb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x52f4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: p-ranav[P]video_device_discovery/src/helpers.cpp
// Function: xioctl(int, int, void*)
int xioctl(int fd, int request, void *arg) {
  int r;
  do {
    r = ioctl (fd, request, arg);
  } while (-1 == r && EINTR == errno);
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x5610
movl %eax, -0x14(%rbp)
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl -0x14(%rbp), %ecx
movb %al, -0x15(%rbp)
jne 0x1051b
callq 0x5050
movq %rax, %rcx
movl $0x4, %eax
cmpl (%rcx), %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x104e2
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/stb/test.c
// Function: test_int
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0, size = 0;
	stb_idict *h;
	h = stb_idict_create();
	for (i = 0, x = x0; i < n; ++i) {
		uint32_t key, val = 1;
		x = hash32(x);
		key = get_key(n, x);
		if (stb_idict_get_flag(h, key, &val)) {
			stb_idict_set(h, key, val + 1);
		} else {
			stb_idict_set(h, key, 1);
			++size;
		}
		z += val;
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u\n", size, z);
	stb_idict_destroy(h);
	return size;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
callq 0xacb0
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jae 0x295e
movl $0x1, (%rsp)
movl 0x18(%rsp), %edi
callq 0x2530
movl %eax, 0x18(%rsp)
movl 0x24(%rsp), %edi
movl 0x18(%rsp), %esi
callq 0x25a0
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movq %rsp, %rdx
callq 0xad80
cmpl $0x0, %eax
je 0x2925
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movl (%rsp), %edx
addl $0x1, %edx
callq 0xb060
jmp 0x2943
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movl $0x1, %edx
callq 0xb060
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl (%rsp), %eax
addl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x28c6
movq 0x23693(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %ecx
leaq 0x1d4bb(%rip), %rsi     # 0x1fe32
movb $0x0, %al
callq 0x21f0
movq 0x8(%rsp), %rdi
callq 0xad00
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_vsnprintf
int stb_vsnprintf(char *s, size_t n, const char *fmt, va_list v)
{
   int res;
   #ifdef _WIN32
   // Could use "_vsnprintf_s(s, n, _TRUNCATE, fmt, v)" ?
   res = _vsnprintf(s,n,fmt,v);
   #else
   res = vsnprintf(s,n,fmt,v);
   #endif
   if (n) s[n-1] = 0;
   // Unix returns length output would require, Windows returns negative when truncated.
   return (res >= (int) n || res < 0) ? -1 : res;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x20c0
movl %eax, 0x4(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x29ef
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl %ecx, %eax
jge 0x2a03
cmpl $0x0, 0x4(%rsp)
jge 0x2a0d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%rsp)
jmp 0x2a14
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_fatal
void stb_fatal(char *s, ...)
{
   va_list a;
   if (stb__file)
      fprintf(stderr, "[%s:%d] ", stb__file, stb__line);
   va_start(a,s);
   fputs("Fatal error: ", stderr);
   vfprintf(stderr, s, a);
   va_end(a);
   fputs("\n", stderr);
   #ifdef STB_DEBUG
   #ifdef _MSC_VER
   #ifndef STB_PTR64
   __asm int 3;   // trap to debugger!
   #else
   __debugbreak();
   #endif
   #else
   __builtin_trap();
   #endif
   #endif
   exit(1);
}

// Assembly:
subq $0xd8, %rsp
testb %al, %al
je 0x364c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xd0(%rsp)
cmpq $0x0, 0x265eb(%rip)     # 0x29c60
je 0x369c
movq 0x2297a(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
movq 0x265d8(%rip), %rdx     # 0x29c60
movl 0x265da(%rip), %ecx     # 0x29c68
leaq 0x1bca5(%rip), %rsi     # 0x1f33a
movb $0x0, %al
callq 0x21f0
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x2292d(%rip), %rax     # 0x25ff8
movq (%rax), %rsi
leaq 0x1bc6e(%rip), %rdi     # 0x1f343
callq 0x2150
movq 0x22917(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
movq 0xd0(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x2330
leaq 0xb0(%rsp), %rax
movq 0x228f0(%rip), %rax     # 0x25ff8
movq (%rax), %rsi
leaq 0x1bc26(%rip), %rdi     # 0x1f338
callq 0x2150
movl $0x1, %edi
callq 0x2360
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_
void stb_(char *s, ...)
{
   if (stb__log_active) {
      FILE *f = fopen(stb__log_filename, "a");
      if (f) {
         va_list a;
         if (stb__log_fileline && stb__file)
            fprintf(f, "[%s:%4d] ", stb__file, stb__line);
         va_start(a,s);
         vfprintf(f, s, a);
         va_end(a);
         fputs("\n", f);
         fclose(f);
      }
   }
}

// Assembly:
subq $0xd8, %rsp
testb %al, %al
je 0x37ac
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xd0(%rsp)
cmpl $0x0, 0x22a1c(%rip)     # 0x261f0
je 0x38aa
movq 0x22a17(%rip), %rdi     # 0x261f8
leaq 0x1bb71(%rip), %rsi     # 0x1f359
callq 0x22f0
movq %rax, 0xc8(%rsp)
cmpq $0x0, 0xc8(%rsp)
je 0x38a8
cmpl $0x0, 0x229e9(%rip)     # 0x261f4
je 0x383a
cmpq $0x0, 0x2644b(%rip)     # 0x29c60
je 0x383a
movq 0xc8(%rsp), %rdi
movq 0x2643a(%rip), %rdx     # 0x29c60
movl 0x2643c(%rip), %ecx     # 0x29c68
leaq 0x1bb28(%rip), %rsi     # 0x1f35b
movb $0x0, %al
callq 0x21f0
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xc8(%rsp), %rdi
movq 0xd0(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x2330
leaq 0xb0(%rsp), %rax
movq 0xc8(%rsp), %rsi
leaq 0x1baa2(%rip), %rdi     # 0x1f338
callq 0x2150
movq 0xc8(%rsp), %rdi
callq 0x20d0
jmp 0x38aa
addq $0xd8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_append_to_file
void stb_append_to_file(char *filename, char *s, ...)
{
   FILE *f = fopen(filename, "a");
   if (f) {
      va_list a;
      va_start(a,s);
      vfprintf(f, s, a);
      va_end(a);
      fputs("\n", f);
      fclose(f);
   }
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0x38fc
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xe0(%rsp), %rdi
leaq 0x1ba2a(%rip), %rsi     # 0x1f359
callq 0x22f0
movq %rax, 0xd0(%rsp)
cmpq $0x0, 0xd0(%rsp)
je 0x39b5
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xd0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x2330
leaq 0xb0(%rsp), %rax
movq 0xd0(%rsp), %rsi
leaq 0x1b995(%rip), %rdi     # 0x1f338
callq 0x2150
movq 0xd0(%rsp), %rdi
callq 0x20d0
addq $0xe8, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_swap
void stb_swap(void *p, void *q, size_t sz)
{
   char buffer[256];
   if (p == q) return;
   if (sz == 4) {
      stb__4 temp    = * ( stb__4 *) p;
      * (stb__4 *) p = * ( stb__4 *) q;
      * (stb__4 *) q = temp;
      return;
   } else if (sz == 8) {
      stb__8 temp    = * ( stb__8 *) p;
      * (stb__8 *) p = * ( stb__8 *) q;
      * (stb__8 *) q = temp;
      return;
   }

   while (sz > sizeof(buffer)) {
      stb_swap(p, q, sizeof(buffer));
      p = (char *) p + sizeof(buffer);
      q = (char *) q + sizeof(buffer);
      sz -= sizeof(buffer);
   }

   memcpy(buffer, p     , sz);
   memcpy(p     , q     , sz);
   memcpy(q     , buffer, sz);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x120(%rsp), %rax
cmpq 0x118(%rsp), %rax
jne 0x39f6
jmp 0x3b3d
cmpq $0x4, 0x110(%rsp)
jne 0x3a36
movq 0x120(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x120(%rsp), %rax
movq 0x118(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq 0x118(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
jmp 0x3b3d
cmpq $0x8, 0x110(%rsp)
jne 0x3a7c
movq 0x120(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x4(%rsp)
movq 0x120(%rsp), %rax
movq 0x118(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x118(%rsp), %rax
movq 0x4(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x3b3d
jmp 0x3a7e
jmp 0x3a80
cmpq $0x100, 0x110(%rsp) # imm = 0x100
jbe 0x3aec
movq 0x120(%rsp), %rdi
movq 0x118(%rsp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x39c0
movq 0x120(%rsp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x120(%rsp)
movq 0x118(%rsp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x118(%rsp)
movq 0x110(%rsp), %rax
subq $0x100, %rax            # imm = 0x100
movq %rax, 0x110(%rsp)
jmp 0x3a80
leaq 0x10(%rsp), %rdi
movq 0x120(%rsp), %rsi
movq 0x110(%rsp), %rdx
callq 0x2230
movq 0x120(%rsp), %rdi
movq 0x118(%rsp), %rsi
movq 0x110(%rsp), %rdx
callq 0x2230
movq 0x118(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x110(%rsp), %rdx
callq 0x2230
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_pointer_array_free
void stb_pointer_array_free(void *q, int len)
{
   void **p = (void **) q;
   int i;
   for (i=0; i < len; ++i)
      free(p[i]);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x3bd9
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x23c0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3baf
addq $0x28, %rsp
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_array_block_alloc
void **stb_array_block_alloc(int count, int blocksize)
{
   int i;
   char *p = (char *) malloc(sizeof(void *) * count + count * blocksize);
   void **q;
   if (p == NULL) return NULL;
   q = (void **) p;
   p += sizeof(void *) * count;
   for (i=0; i < count; ++i)
      q[i] = p + i * blocksize;
   return q;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movl %esi, 0x18(%rsp)
movslq 0x1c(%rsp), %rdi
shlq $0x3, %rdi
movl 0x1c(%rsp), %eax
imull 0x18(%rsp), %eax
cltq
addq %rax, %rdi
callq 0x2260
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x3c20
movq $0x0, 0x20(%rsp)
jmp 0x3c84
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movslq 0x1c(%rsp), %rax
shlq $0x3, %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x3c7b
movq 0x8(%rsp), %rdx
movl 0x14(%rsp), %eax
imull 0x18(%rsp), %eax
cltq
addq %rax, %rdx
movq (%rsp), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3c44
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_newell_normal
void stb_newell_normal(float *normal, int num_vert, float **vert, int normalize)
{
   int i,j;
   float p;
   normal[0] = normal[1] = normal[2] = 0;
   for (i=num_vert-1,j=0; j < num_vert; i=j++) {
      float *u = vert[i];
      float *v = vert[j];
      normal[0] += (u[1] - v[1]) * (u[2] + v[2]);
      normal[1] += (u[2] - v[2]) * (u[0] + v[0]);
      normal[2] += (u[0] - v[0]) * (u[1] + v[1]);
   }
   if (normalize) {
      p = normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2];
      p = (float) (1.0 / sqrt(p));
      normal[0] *= p;
      normal[1] *= p;
      normal[2] *= p;
   }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x30(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rax)
movq 0x30(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax)
movq 0x30(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movl 0x2c(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x3f39
movq 0x20(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movss 0x4(%rax), %xmm0
movq (%rsp), %rax
subss 0x4(%rax), %xmm0
movq 0x8(%rsp), %rax
movss 0x8(%rax), %xmm2
movq (%rsp), %rax
addss 0x8(%rax), %xmm2
movq 0x30(%rsp), %rax
movss (%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax)
movq 0x8(%rsp), %rax
movss 0x8(%rax), %xmm0
movq (%rsp), %rax
subss 0x8(%rax), %xmm0
movq 0x8(%rsp), %rax
movss (%rax), %xmm2
movq (%rsp), %rax
addss (%rax), %xmm2
movq 0x30(%rsp), %rax
movss 0x4(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x4(%rax)
movq 0x8(%rsp), %rax
movss (%rax), %xmm0
movq (%rsp), %rax
subss (%rax), %xmm0
movq 0x8(%rsp), %rax
movss 0x4(%rax), %xmm2
movq (%rsp), %rax
addss 0x4(%rax), %xmm2
movq 0x30(%rsp), %rax
movss 0x8(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x8(%rax)
movl 0x14(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rsp)
movl %eax, 0x18(%rsp)
jmp 0x3e3f
cmpl $0x0, 0x1c(%rsp)
je 0x3ff9
movq 0x30(%rsp), %rax
movss (%rax), %xmm1
movq 0x30(%rsp), %rax
movss (%rax), %xmm2
movq 0x30(%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0x30(%rsp), %rax
mulss 0x4(%rax), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq 0x30(%rsp), %rax
movss 0x8(%rax), %xmm0
movq 0x30(%rsp), %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x10(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x2380
movaps %xmm0, %xmm1
movsd 0x1b072(%rip), %xmm0    # 0x1f020
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x10(%rsp), %xmm0
movq 0x30(%rsp), %rax
mulss (%rax), %xmm0
movss %xmm0, (%rax)
movss 0x10(%rsp), %xmm0
movq 0x30(%rsp), %rax
mulss 0x4(%rax), %xmm0
movss %xmm0, 0x4(%rax)
movss 0x10(%rsp), %xmm0
movq 0x30(%rsp), %rax
mulss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
addq $0x38, %rsp
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_box_face_vertex_axis_side
int stb_box_face_vertex_axis_side(int face_number, int vertex_number, int axis)
{
   static int box_vertices[6][4][3] =
   {
      { { 1,1,1 }, { 1,0,1 }, { 1,0,0 }, { 1,1,0 } },
      { { 0,0,0 }, { 0,0,1 }, { 0,1,1 }, { 0,1,0 } },
      { { 0,0,0 }, { 0,1,0 }, { 1,1,0 }, { 1,0,0 } },
      { { 0,0,0 }, { 1,0,0 }, { 1,0,1 }, { 0,0,1 } },
      { { 1,1,1 }, { 0,1,1 }, { 0,0,1 }, { 1,0,1 } },
      { { 1,1,1 }, { 1,1,0 }, { 0,1,0 }, { 0,1,1 } },
   };
   assert(face_number >= 0 && face_number < 6);
   assert(vertex_number >= 0 && vertex_number < 4);
   assert(axis >= 0 && axis < 3);
   return box_vertices[face_number][vertex_number][axis];
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0x4020
cmpl $0x6, 0x14(%rsp)
jge 0x4020
jmp 0x403f
leaq 0x1b33e(%rip), %rdi     # 0x1f365
leaq 0x1b35b(%rip), %rsi     # 0x1f389
movl $0x52e, %edx            # imm = 0x52E
leaq 0x1b357(%rip), %rcx     # 0x1f391
callq 0x2140
cmpl $0x0, 0x10(%rsp)
jl 0x404f
cmpl $0x4, 0x10(%rsp)
jge 0x404f
jmp 0x406e
leaq 0x1b36c(%rip), %rdi     # 0x1f3c2
leaq 0x1b32c(%rip), %rsi     # 0x1f389
movl $0x52f, %edx            # imm = 0x52F
leaq 0x1b328(%rip), %rcx     # 0x1f391
callq 0x2140
cmpl $0x0, 0xc(%rsp)
jl 0x407e
cmpl $0x3, 0xc(%rsp)
jge 0x407e
jmp 0x409d
leaq 0x1b365(%rip), %rdi     # 0x1f3ea
leaq 0x1b2fd(%rip), %rsi     # 0x1f389
movl $0x530, %edx            # imm = 0x530
leaq 0x1b2f9(%rip), %rcx     # 0x1f391
callq 0x2140
movslq 0x14(%rsp), %rcx
leaq 0x22157(%rip), %rax     # 0x26200
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_linear_controller
void stb_linear_controller(float *curpos, float target_pos, float acc, float deacc, float dt)
{
   float sign = 1, p, cp = *curpos;
   if (cp == target_pos) return;
   if (target_pos < cp) {
      target_pos = -target_pos;
      cp = -cp;
      sign = -1;
   }
   // first decelerate
   if (cp < 0) {
      p = cp + deacc * dt;
      if (p > 0) {
         p = 0;
         dt = dt - cp / deacc;
         if (dt < 0) dt = 0;
      } else {
         dt = 0;
      }
      cp = p;
   }
   // now accelerate
   p = cp + acc*dt;
   if (p > target_pos) p = target_pos;
   *curpos = p * sign;
   // @TODO: testing
}

// Assembly:
movq %rdi, -0x8(%rsp)
movss %xmm0, -0xc(%rsp)
movss %xmm1, -0x10(%rsp)
movss %xmm2, -0x14(%rsp)
movss %xmm3, -0x18(%rsp)
movss 0x1af67(%rip), %xmm0    # 0x1f05c
movss %xmm0, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x24(%rsp)
movss -0x24(%rsp), %xmm0
ucomiss -0xc(%rsp), %xmm0
jne 0x411e
jp 0x411e
jmp 0x4244
movss -0xc(%rsp), %xmm1
movss -0x24(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x416f
movss -0xc(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0xc(%rsp)
movss -0x24(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x24(%rsp)
movss 0x1aef7(%rip), %xmm0    # 0x1f060
movss %xmm0, -0x1c(%rsp)
xorps %xmm0, %xmm0
ucomiss -0x24(%rsp), %xmm0
jbe 0x41f6
movss -0x24(%rsp), %xmm1
movss -0x14(%rsp), %xmm0
movss -0x18(%rsp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x20(%rsp)
movss -0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x41e1
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rsp)
movss -0x18(%rsp), %xmm0
movss -0x24(%rsp), %xmm1
divss -0x14(%rsp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x18(%rsp)
xorps %xmm0, %xmm0
ucomiss -0x18(%rsp), %xmm0
jbe 0x41df
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rsp)
jmp 0x41ea
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rsp)
movss -0x20(%rsp), %xmm0
movss %xmm0, -0x24(%rsp)
movss -0x24(%rsp), %xmm1
movss -0x10(%rsp), %xmm0
movss -0x18(%rsp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x20(%rsp)
movss -0x20(%rsp), %xmm0
ucomiss -0xc(%rsp), %xmm0
jbe 0x422f
movss -0xc(%rsp), %xmm0
movss %xmm0, -0x20(%rsp)
movss -0x20(%rsp), %xmm0
mulss -0x1c(%rsp), %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_is_prime
int stb_is_prime(unsigned int m)
{
   unsigned int i,j;
   if (m < 2) return 0;
   if (m == 2) return 1;
   if (!(m & 1)) return 0;
   if (m % 3 == 0) return (m == 3);
   for (i=5; (j=i*i), j <= m && j > i; i += 6) {
      if (m %   i   == 0) return 0;
      if (m % (i+2) == 0) return 0;
   }
   return 1;
}

// Assembly:
movl %edi, -0x8(%rsp)
cmpl $0x2, -0x8(%rsp)
jae 0x4318
movl $0x0, -0x4(%rsp)
jmp 0x43f9
cmpl $0x2, -0x8(%rsp)
jne 0x432c
movl $0x1, -0x4(%rsp)
jmp 0x43f9
movl -0x8(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4345
movl $0x0, -0x4(%rsp)
jmp 0x43f9
movl -0x8(%rsp), %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x0, %edx
jne 0x436d
cmpl $0x3, -0x8(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
jmp 0x43f9
movl $0x5, -0xc(%rsp)
movl -0xc(%rsp), %eax
imull -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %ecx
xorl %eax, %eax
cmpl -0x8(%rsp), %ecx
movb %al, -0x11(%rsp)
ja 0x43a1
movl -0x10(%rsp), %eax
cmpl -0xc(%rsp), %eax
seta %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
testb $0x1, %al
jne 0x43ab
jmp 0x43f1
movl -0x8(%rsp), %eax
xorl %edx, %edx
divl -0xc(%rsp)
cmpl $0x0, %edx
jne 0x43c4
movl $0x0, -0x4(%rsp)
jmp 0x43f9
movl -0x8(%rsp), %eax
movl -0xc(%rsp), %ecx
addl $0x2, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x0, %edx
jne 0x43e2
movl $0x0, -0x4(%rsp)
jmp 0x43f9
jmp 0x43e4
movl -0xc(%rsp), %eax
addl $0x6, %eax
movl %eax, -0xc(%rsp)
jmp 0x4375
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_power_of_two_nearest_prime
unsigned int stb_power_of_two_nearest_prime(int n)
{
   static signed char tab[32] = { 0,0,0,0,1,0,-1,0,1,-1,-1,3,-1,0,-1,2,1,
                                   0,2,0,-1,-4,-1,5,-1,18,-2,15,2,-1,2,0 };
   if (!tab[0]) {
      int i;
      for (i=0; i < 32; ++i)
         tab[i] = (1 << i) + 2*tab[i] - 1;
      tab[1] = 2;
      tab[0] = 1;
   }
   if (n >= 32) return 0xfffffffb;
   return tab[n];
}

// Assembly:
movl %edi, -0x8(%rsp)
cmpb $0x0, 0x21f15(%rip)     # 0x26320
jne 0x446a
movl $0x0, -0xc(%rsp)
cmpl $0x20, -0xc(%rsp)
jge 0x445c
movl -0xc(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq -0xc(%rsp), %rdx
leaq 0x21eed(%rip), %rcx     # 0x26320
movsbl (%rcx,%rdx), %ecx
shll %ecx
addl %ecx, %eax
subl $0x1, %eax
movb %al, %dl
movslq -0xc(%rsp), %rcx
leaq 0x21ed4(%rip), %rax     # 0x26320
movb %dl, (%rax,%rcx)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x4415
movb $0x2, 0x21ebe(%rip)     # 0x26321
movb $0x1, 0x21eb6(%rip)     # 0x26320
cmpl $0x20, -0x8(%rsp)
jl 0x447b
movl $0xfffffffb, -0x4(%rsp) # imm = 0xFFFFFFFB
jmp 0x448f
movslq -0x8(%rsp), %rcx
leaq 0x21e99(%rip), %rax     # 0x26320
movsbl (%rax,%rcx), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/stb/./stb.h
// Function: stb_log2_floor
int stb_log2_floor(unsigned int n)
{
   static signed char log2_4[16] = { -1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3 };

   // 2 compares if n < 16, 3 compares otherwise
   if (n < (1U << 14))
        if (n < (1U <<  4))        return     0 + log2_4[n      ];
        else if (n < (1U <<  9))      return  5 + log2_4[n >>  5];
             else                     return 10 + log2_4[n >> 10];
   else if (n < (1U << 24))
             if (n < (1U << 19))      return 15 + log2_4[n >> 15];
             else                     return 20 + log2_4[n >> 20];
        else if (n < (1U << 29))      return 25 + log2_4[n >> 25];
             else                     return 30 + log2_4[n >> 30];
}

// Assembly:
movl %edi, -0x8(%rsp)
cmpl $0x4000, -0x8(%rsp)     # imm = 0x4000
jae 0x4720
cmpl $0x10, -0x8(%rsp)
jae 0x46d2
movl -0x8(%rsp), %eax
movl %eax, %ecx
leaq 0x21c7e(%rip), %rax     # 0x26340
movsbl (%rax,%rcx), %eax
addl $0x0, %eax
movl %eax, -0x4(%rsp)
jmp 0x47b8
cmpl $0x200, -0x8(%rsp)      # imm = 0x200
jae 0x46fe
movl -0x8(%rsp), %eax
shrl $0x5, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x21c52(%rip), %rax     # 0x26340
movsbl (%rax,%rcx), %eax
addl $0x5, %eax
movl %eax, -0x4(%rsp)
jmp 0x47b8
movl -0x8(%rsp), %eax
shrl $0xa, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x21c30(%rip), %rax     # 0x26340
movsbl (%rax,%rcx), %eax
addl $0xa, %eax
movl %eax, -0x4(%rsp)
jmp 0x47b8
cmpl $0x1000000, -0x8(%rsp)  # imm = 0x1000000
jae 0x4772
cmpl $0x80000, -0x8(%rsp)    # imm = 0x80000
jae 0x4753
movl -0x8(%rsp), %eax
shrl $0xf, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x21bfa(%rip), %rax     # 0x26340
movsbl (%rax,%rcx), %eax
addl $0xf, %eax
movl %eax, -0x4(%rsp)
jmp 0x47b8
movl -0x8(%rsp), %eax
shrl $0x14, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x21bdb(%rip), %rax     # 0x26340
movsbl (%rax,%rcx), %eax
addl $0x14, %eax
movl %eax, -0x4(%rsp)
jmp 0x47b8
cmpl $0x20000000, -0x8(%rsp) # imm = 0x20000000
jae 0x479b
movl -0x8(%rsp), %eax
shrl $0x19, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x21bb2(%rip), %rax     # 0x26340
movsbl (%rax,%rcx), %eax
addl $0x19, %eax
movl %eax, -0x4(%rsp)
jmp 0x47b8
movl -0x8(%rsp), %eax
shrl $0x1e, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x21b93(%rip), %rax     # 0x26340
movsbl (%rax,%rcx), %eax
addl $0x1e, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)