Datasets:
LLM4Binary
/
decompile-bench-makefile

Dataset card Data Studio Files
xet
Community
1
name
stringlengths
1
4.98k
code
stringlengths
61
2.07M
asm
stringlengths
57
12.9M
file
stringlengths
18
192
f_rect
static int f_rect(lua_State *L) { Uint8 color = (Uint8)luaL_checkinteger(L, 1); int x0 = (int)luaL_checknumber(L, 2); int y0 = (int)luaL_checknumber(L, 3); int x1 = (int)luaL_checknumber(L, 4); int y1 = (int)luaL_checknumber(L, 5); int x, y; if (x0 > x1) swap(int, x0, x1); if (y0 > y1) swap(int, y0, y1); for (x = x0; x <= x1; ++x) { _pixel(color, x, y0); _pixel(color, x, y1); } for (y = y0; y <= y1; ++y) { _pixel(color, x0, y); _pixel(color, x1, y); } return 0; }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx movq %rdi, %r14 movl $0x1, %esi callq 0xe462 movq %rax, %rbx movq %r14, %rdi movl $0x2, %esi callq 0xe3e3 cvttsd2si %xmm0, %ebp movq %r14, %rdi movl $0x3, %esi callq 0xe3e3 cvttsd2si %xmm0, %r15d movq %r14, %rdi movl $0x4, %esi callq 0xe3e3 cvttsd2si %xmm0, %r12d movq %r14, %rdi movl $0x5, %esi callq 0xe3e3 cvttsd2si %xmm0, %r9d cmpl %r12d, %ebp movl %r12d, %eax cmovgl %ebp, %eax movl %r12d, %ecx cmovll %ebp, %ecx cmpl %r9d, %r15d movl %r9d, %edx cmovgl %r15d, %edx cmovll %r15d, %r9d movl 0x112d41(%rip), %r10d # 0x142500 movl 0x112d3e(%rip), %r11d # 0x142504 leal (%r11,%r9), %esi movl 0x112d38(%rip), %edi # 0x142508 addl %edx, %r11d movslq %ebp, %r8 movslq %r12d, %r14 subq %r14, %r8 movq %r8, %r15 negq %r15 cmovsq %r8, %r15 movl 0x112d1f(%rip), %r8d # 0x14250c incl %r15d leal (%r10,%rcx), %ebp leaq 0x12d05(%rip), %r14 # 0x42500 testl %ebp, %ebp js 0x2f836 cmpl %edi, %ebp jge 0x2f81a testl %esi, %esi js 0x2f81a cmpl %r8d, %esi jge 0x2f81a movl %ebp, %r12d shlq $0xa, %r12 addq %r14, %r12 movb %bl, (%rsi,%r12) cmpl %edi, %ebp jge 0x2f836 testl %r11d, %r11d js 0x2f836 cmpl %r8d, %r11d jge 0x2f836 movl %ebp, %r12d shlq $0xa, %r12 addq %r14, %r12 movb %bl, (%r11,%r12) incl %ebp decl %r15d jne 0x2f7fb addl %r10d, %ecx addl %r10d, %eax subl %r9d, %edx incl %edx movq %rcx, %r9 shlq $0xa, %r9 addq %r14, %r9 movq %rax, %r10 shlq $0xa, %r10 addq %r14, %r10 testl %ecx, %ecx js 0x2f874 cmpl %edi, %ecx jge 0x2f874 testl %esi, %esi js 0x2f874 cmpl %r8d, %esi jge 0x2f874 movl %esi, %r11d movb %bl, (%r11,%r9) testl %eax, %eax js 0x2f88c cmpl %edi, %eax jge 0x2f88c testl %esi, %esi js 0x2f88c cmpl %r8d, %esi jge 0x2f88c movl %esi, %r11d movb %bl, (%r11,%r10) incl %esi decl %edx jne 0x2f85c xorl %eax, %eax popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_line
static int f_line(lua_State *L) { Uint8 color = (Uint8)luaL_checkinteger(L, 1); int x0 = (int)luaL_checknumber(L, 2); int y0 = (int)luaL_checknumber(L, 3); int x1 = (int)luaL_checknumber(L, 4); int y1 = (int)luaL_checknumber(L, 5); int dx = SDL_abs(x1 - x0), sx = x0 < x1 ? 1 : -1; int dy = SDL_abs(y1 - y0), sy = y0 < y1 ? 1 : -1; int err = (dx > dy ? dx : -dy) / 2, e2; for (;;) { _pixel(color, x0, y0); if (x0 == x1 && y0 == y1) break; e2 = err; if (e2 > -dx) { err -= dy; x0 += sx; } if (e2 < dy) { err += dx; y0 += sy; } } return 0; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %r14 movl $0x1, %esi callq 0xe462 movq %rax, 0x10(%rsp) movq %r14, %rdi movl $0x2, %esi callq 0xe3e3 cvttsd2si %xmm0, %r15d movq %r14, %rdi movl $0x3, %esi callq 0xe3e3 cvttsd2si %xmm0, %r12d movq %r14, %rdi movl $0x4, %esi callq 0xe3e3 cvttsd2si %xmm0, %r13d movq %r14, %rdi movl $0x5, %esi callq 0xe3e3 cvttsd2si %xmm0, %eax movl %eax, 0x8(%rsp) xorl %ebx, %ebx movl %r13d, %edi subl %r15d, %edi setg %bl callq 0x60a0 movl %eax, %ebp leal -0x1(,%rbx,2), %ebx xorl %r14d, %r14d movl 0x8(%rsp), %edi subl %r12d, %edi setg %r14b callq 0x60a0 movl %eax, %esi negl %esi cmpl %eax, %ebp cmovgl %ebp, %esi leal -0x1(,%r14,2), %ecx movl %esi, %r9d shrl $0x1f, %r9d addl %esi, %r9d sarl %r9d movl 0x112ba7(%rip), %r11d # 0x142500 movl 0x112ba4(%rip), %r14d # 0x142504 movl 0x112ba1(%rip), %r8d # 0x142508 movl 0x112b9f(%rip), %edx # 0x14250c movl %edx, 0xc(%rsp) movl %ebp, %r10d negl %r10d movl %r11d, %esi addl %r15d, %esi js 0x2f9ac cmpl %r8d, %esi jge 0x2f9ac movl %r14d, %edi addl %r12d, %edi js 0x2f9ac cmpl 0xc(%rsp), %edi jge 0x2f9ac movl %esi, %esi movl %edi, %edi shlq $0xa, %rsi leaq 0x12b5f(%rip), %rdx # 0x42500 addq %rdx, %rsi movq 0x10(%rsp), %rdx movb %dl, (%rdi,%rsi) cmpl %r13d, %r15d jne 0x2f9b8 cmpl 0x8(%rsp), %r12d je 0x2f9f0 cmpl %r10d, %r9d movl $0x0, %esi cmovgl %eax, %esi movl $0x0, %edi cmovgl %ebx, %edi movl %r9d, %edx subl %esi, %edx addl %edi, %r15d cmpl %eax, %r9d movl $0x0, %esi cmovll %ecx, %esi movl $0x0, %r9d cmovll %ebp, %r9d addl %esi, %r12d addl %edx, %r9d jmp 0x2f977 xorl %eax, %eax addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_circle
static int f_circle(lua_State *L) { Uint8 color = (Uint8)luaL_checkinteger(L, 1); int x0 = (int)luaL_checknumber(L, 2); int y0 = (int)luaL_checknumber(L, 3); int radius = (int)luaL_checknumber(L, 4); int fill = lua_toboolean(L, 5); int r0sq = fill ? 0 : (radius - 1) * (radius - 1); int r1sq = radius * radius; int x, y, dx, dy, dist; for (y = y0 - radius; y <= y0 + radius; ++y) { dy = y0 - y; dy *= dy; for (x = x0 - radius; x <= x0 + radius; ++x) { dx = x0 - x; dx *= dx; dist = dx + dy; if ((dist >= r0sq) && (dist < r1sq)) _pixel(color, x, y); } } return 0; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rdi, %r14 movl $0x1, %esi callq 0xe462 movq %rax, %rbx movq %r14, %rdi movl $0x2, %esi callq 0xe3e3 movsd %xmm0, (%rsp) movq %r14, %rdi movl $0x3, %esi callq 0xe3e3 cvttsd2si %xmm0, %r15d movq %r14, %rdi movl $0x4, %esi callq 0xe3e3 cvttsd2si %xmm0, %r12d movq %r14, %rdi movl $0x5, %esi callq 0x9fd6 movl %r15d, %ecx subl %r12d, %ecx movq %r15, 0x30(%rsp) movq %r12, 0x18(%rsp) leal (%r12,%r15), %edx movl %edx, 0x14(%rsp) cmpl %edx, %ecx jg 0x2fb7c cvttsd2si (%rsp), %esi movq 0x18(%rsp), %rdx leal -0x1(%rdx), %edi imull %edi, %edi movl %edx, %r8d imull %edx, %r8d movl %esi, %r9d subl %edx, %r9d movl %r9d, (%rsp) leal (%rdx,%rsi), %r9d movl %r9d, 0x10(%rsp) movl 0x112a51(%rip), %r9d # 0x142504 movq %r9, 0x20(%rsp) movl 0x112a4a(%rip), %ebp # 0x142508 movl 0x112a47(%rip), %r14d # 0x14250c leal 0x1(,%rdx,2), %r9d movl %r9d, 0xc(%rsp) addl 0x112a28(%rip), %esi # 0x142500 subl %edx, %esi movq %rsi, 0x28(%rsp) movl 0x10(%rsp), %edx cmpl %edx, (%rsp) jg 0x2fb6d movq 0x30(%rsp), %rdx movl %edx, %r15d subl %ecx, %r15d imull %r15d, %r15d movq 0x20(%rsp), %rdx leal (%rdx,%rcx), %r13d movq 0x28(%rsp), %rdx movl %edx, %esi movq 0x18(%rsp), %rdx movl %edx, %r10d movl 0xc(%rsp), %edx testl %eax, %eax setne %r9b movl %r10d, %r12d imull %r10d, %r12d addl %r15d, %r12d cmpl %r12d, %edi setbe %r11b orb %r9b, %r11b cmpb $0x1, %r11b jne 0x2fb64 cmpl %r8d, %r12d jae 0x2fb64 testl %esi, %esi js 0x2fb64 cmpl %ebp, %esi jge 0x2fb64 testl %r13d, %r13d js 0x2fb64 cmpl %r14d, %r13d jge 0x2fb64 movl %esi, %r9d shlq $0xa, %r9 leaq 0x129a4(%rip), %r11 # 0x42500 addq %r11, %r9 movb %bl, (%r13,%r9) decl %r10d incl %esi decl %edx jne 0x2fb17 leal 0x1(%rcx), %edx cmpl 0x14(%rsp), %ecx movl %edx, %ecx jne 0x2fadf xorl %eax, %eax addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_translate
static int f_translate(lua_State *L) { if (lua_gettop(L) == 2) { int x = (int)luaL_checknumber(L, 1); int y = (int)luaL_checknumber(L, 2); translation.x = x; translation.y = y; } lua_pushinteger(L, translation.x); lua_pushinteger(L, translation.y); return 2; }
pushq %rbx subq $0x10, %rsp movq %rdi, %rbx callq 0x8f4d cmpl $0x2, %eax jne 0x2fbd9 movq %rbx, %rdi movl $0x1, %esi callq 0xe3e3 movapd %xmm0, (%rsp) movq %rbx, %rdi movl $0x2, %esi callq 0xe3e3 movapd (%rsp), %xmm1 unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0] cvttpd2dq %xmm1, %xmm0 movlpd %xmm0, 0x11292d(%rip) # 0x142500 movd %xmm0, %eax jmp 0x2fbdf movl 0x112921(%rip), %eax # 0x142500 movslq %eax, %rsi movq %rbx, %rdi callq 0xa4be movslq 0x112913(%rip), %rsi # 0x142504 movq %rbx, %rdi callq 0xa4be movl $0x2, %eax addq $0x10, %rsp popq %rbx retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_sprite
static int f_sprite(lua_State *L) { size_t length; Uint8 color; int x, y, w, h; int x0 = (int)luaL_checknumber(L, 1); int y0 = (int)luaL_checknumber(L, 2); const char *data = luaL_checklstring(L, 3, &length); int transparent = (int)luaL_optinteger(L, 4, -1); switch (length) { case 64: w = h = 8; break; case 256: w = h = 16; break; case 1024: w = h = 32; break; case 384: w = 16; h = 24; break; default: return luaL_argerror(L, 3, "invalid sprite data length"); } for (y = y0; y < y0 + h; ++y) { for (x = x0; x < x0 + w; ++x) { color = sprite_color_map[(*data++) & 127]; if (color != transparent) _pixel(color, x, y); } } return 0; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %r14 movl $0x1, %esi callq 0xe3e3 movsd %xmm0, (%rsp) movq %r14, %rdi movl $0x2, %esi callq 0xe3e3 movsd %xmm0, 0x8(%rsp) leaq 0x10(%rsp), %r15 movq %r14, %rdi movl $0x3, %esi movq %r15, %rdx callq 0xe339 movq %rax, %rbx movq %r14, %rdi movl $0x4, %esi movq $-0x1, %rdx callq 0xe4bd movq (%r15), %rcx cmpq $0x17f, %rcx # imm = 0x17F jg 0x2fc8a cmpq $0x40, %rcx je 0x2fcc1 cmpq $0x100, %rcx # imm = 0x100 jne 0x2fca8 movl $0x10, %ecx movl $0x10, %esi jmp 0x2fcd7 cmpq $0x180, %rcx # imm = 0x180 je 0x2fccd cmpq $0x400, %rcx # imm = 0x400 jne 0x2fca8 movl $0x20, %ecx movl $0x20, %esi jmp 0x2fcd7 leaq 0x5829(%rip), %rdx # 0x354d8 movq %r14, %rdi movl $0x3, %esi callq 0xdabf jmp 0x2fd61 movl $0x8, %ecx movl $0x8, %esi jmp 0x2fcd7 movl $0x18, %esi movl $0x10, %ecx cvttsd2si (%rsp), %edx cvttsd2si 0x8(%rsp), %edi addl %edi, %esi movl %edx, (%rsp) addl %edx, %ecx movl 0x112811(%rip), %edx # 0x142500 movl 0x11280e(%rip), %r9d # 0x142504 movl 0x11280b(%rip), %r10d # 0x142508 movl 0x112808(%rip), %r11d # 0x14250c leaq 0x51b5(%rip), %r14 # 0x34ec0 leaq 0x127ee(%rip), %r15 # 0x42500 leal (%r9,%rdi), %r12d movl (%rsp), %ebp movzbl (%rbx), %r8d andl $0x7f, %r8d movzbl (%r8,%r14), %r13d cmpl %eax, %r13d je 0x2fd50 movl %edx, %r8d addl %ebp, %r8d js 0x2fd50 cmpl %r10d, %r8d jge 0x2fd50 testl %r12d, %r12d js 0x2fd50 cmpl %r11d, %r12d jge 0x2fd50 movl %r8d, %r8d shlq $0xa, %r8 addq %r15, %r8 movb %r13b, (%r12,%r8) incq %rbx incl %ebp cmpl %ecx, %ebp jl 0x2fd19 incl %edi cmpl %esi, %edi jl 0x2fd12 xorl %eax, %eax addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_print
static int f_print(lua_State *L) { int x, y; Uint8 glyph; Uint8 color = (Uint8)luaL_checkinteger(L, 1); int x0 = (int)luaL_checknumber(L, 2); int y0 = (int)luaL_checknumber(L, 3); const char *str = luaL_checkstring(L, 4); for (; *str; ++str, x0 += 8) { for (y = 0; y < 8; ++y) { glyph = font8x8[*str & 127][y]; for (x = 0; x < 8; ++x) { if (glyph & (1 << x)) _pixel(color, x0 + x, y0 + y); } } } return 0; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %r14 movl $0x1, %esi callq 0xe462 movq %rax, %rbx movq %r14, %rdi movl $0x2, %esi callq 0xe3e3 movsd %xmm0, 0x8(%rsp) movq %r14, %rdi movl $0x3, %esi callq 0xe3e3 movsd %xmm0, 0x10(%rsp) movq %r14, %rdi movl $0x4, %esi xorl %edx, %edx callq 0xe339 cmpb $0x0, (%rax) je 0x2fe99 cvttsd2si 0x10(%rsp), %edi cvttsd2si 0x8(%rsp), %r8d movslq 0x112720(%rip), %r10 # 0x142500 movslq 0x11271d(%rip), %rcx # 0x142504 movslq 0x11271a(%rip), %rdx # 0x142508 movslq 0x112717(%rip), %rsi # 0x14250c movslq %edi, %rdi movslq %r8d, %r9 addq %r10, %r9 movq %r9, %r8 shlq $0xa, %r8 leaq 0x126f4(%rip), %r11 # 0x42500 addq %rdi, %r11 addq %rcx, %r11 addq %r8, %r11 leaq 0x5124(%rip), %r10 # 0x34f40 movq %r11, 0x8(%rsp) xorl %r14d, %r14d movzbl (%rax), %r8d andl $0x7f, %r8d leaq (%r10,%r8,8), %r8 movzbl (%r14,%r8), %ebp leaq (%r14,%rdi), %r15 addq %rcx, %r15 movq %r11, %r12 xorl %r13d, %r13d btl %r13d, %ebp jae 0x2fe63 movq %r9, %r8 addq %r13, %r8 js 0x2fe63 cmpq %rdx, %r8 jge 0x2fe63 testq %r15, %r15 js 0x2fe63 cmpq %rsi, %r15 jge 0x2fe63 movb %bl, (%r12) incq %r13 addq $0x400, %r12 # imm = 0x400 cmpq $0x8, %r13 jne 0x2fe42 incq %r14 incq %r11 cmpq $0x8, %r14 jne 0x2fe24 movq 0x8(%rsp), %r11 addq $0x2000, %r11 # imm = 0x2000 addq $0x8, %r9 cmpb $0x0, 0x1(%rax) leaq 0x1(%rax), %rax jne 0x2fe1c xorl %eax, %eax addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_play
static int f_play(lua_State *L) { AudioChannel *channel; int i = (int)luaL_checkinteger(L, 1); const char *str = luaL_checkstring(L, 2); luaL_argcheck(L, i >= 0 && i < PX_AUDIO_CHANNELS, 1, "invalid channel"); if (audio_device) { SDL_LockAudioDevice(audio_device); channel = &channels[i]; mml_reset_channel(channel); channel->source = channel->in = SDL_strdup(str); channel->looping = lua_toboolean(L, 3); SDL_UnlockAudioDevice(audio_device); } return 0; }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx movl $0x1, %esi callq 0xe462 movq %rax, %r14 movq %rbx, %rdi movl $0x2, %esi xorl %edx, %edx callq 0xe339 movq %rax, %r15 testl $0xfffffff8, %r14d # imm = 0xFFFFFFF8 je 0x2fef1 leaq 0x560f(%rip), %rdx # 0x354f3 movq %rbx, %rdi movl $0x1, %esi callq 0xdabf movl 0x125f1(%rip), %edi # 0x424e8 testl %edi, %edi je 0x2ff45 callq 0x64b0 movslq %r14d, %rax imulq $0x38, %rax, %r14 leaq 0x112602(%rip), %r12 # 0x142510 leaq (%r12,%r14), %rdi callq 0x3084c movq %r15, %rdi callq 0x61b0 movq %rax, 0x8(%r14,%r12) movq %rax, (%r14,%r12) movq %rbx, %rdi movl $0x3, %esi callq 0x9fd6 movl %eax, 0x10(%r14,%r12) movl 0x125a8(%rip), %edi # 0x424e8 callq 0x6770 xorl %eax, %eax addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_stop
static int f_stop(lua_State *L) { int i = (int)luaL_checkinteger(L, 1); luaL_argcheck(L, i >= 0 && i < PX_AUDIO_CHANNELS, 1, "invalid channel"); if (audio_device) { SDL_LockAudioDevice(audio_device); mml_reset_channel(&channels[i]); SDL_UnlockAudioDevice(audio_device); } return 0; }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %r14 movl $0x1, %esi callq 0xe462 movq %rax, %rbx testl $0xfffffff8, %ebx # imm = 0xFFFFFFF8 je 0x2ff83 leaq 0x557d(%rip), %rdx # 0x354f3 movq %r14, %rdi movl $0x1, %esi callq 0xdabf movl 0x1255f(%rip), %edi # 0x424e8 testl %edi, %edi je 0x2ffb3 callq 0x64b0 movslq %ebx, %rax imulq $0x38, %rax, %rax leaq 0x112570(%rip), %rdi # 0x142510 addq %rax, %rdi callq 0x3084c movl 0x1253a(%rip), %edi # 0x424e8 callq 0x6770 xorl %eax, %eax addq $0x8, %rsp popq %rbx popq %r14 retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_mouse
static int f_mouse(lua_State *L) { Input *input = &inputs[_check_controller(L)]; lua_pushinteger(L, input->mouse.x + translation.x); lua_pushinteger(L, input->mouse.y + translation.y); return 2; }
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx callq 0x3088a cltq leaq (%rax,%rax,2), %r14 leaq 0x112a40(%rip), %r15 # 0x142ae0 movslq 0x4(%r15,%r14,4), %rax movslq 0x112454(%rip), %rsi # 0x142500 addq %rax, %rsi movq %rbx, %rdi callq 0xa4be movslq 0x8(%r15,%r14,4), %rax movslq 0x112441(%rip), %rsi # 0x142504 addq %rax, %rsi movq %rbx, %rdi callq 0xa4be movl $0x2, %eax popq %rbx popq %r14 popq %r15 retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_clipboard
static int f_clipboard(lua_State *L) { if (lua_gettop(L) > 0) { const char *text = luaL_checkstring(L, 1); if (SDL_SetClipboardText(text)) luaL_error(L, "SDL_SetClipboardText() failed: %s", SDL_GetError()); lua_pushstring(L, text); return 1; } else { lua_pushstring(L, SDL_GetClipboardText()); return 1; } }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx callq 0x8f4d testl %eax, %eax jle 0x30122 movq %rbx, %rdi movl $0x1, %esi xorl %edx, %edx callq 0xe339 movq %rax, %r14 movq %rax, %rdi callq 0x67d0 testl %eax, %eax je 0x3012a callq 0x6380 leaq 0x541d(%rip), %rsi # 0x35530 movq %rbx, %rdi movq %rax, %rdx xorl %eax, %eax callq 0xdb8f jmp 0x3012a callq 0x6220 movq %rax, %r14 movq %rbx, %rdi movq %r14, %rsi callq 0xa67f movl $0x1, %eax addq $0x8, %rsp popq %rbx popq %r14 retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_randomseed
static int f_randomseed(lua_State *L) { if (lua_gettop(L) > 0) { Uint32 x = (Uint32)luaL_checkinteger(L, 1); px_randomseed(x); } lua_pushinteger(L, (lua_Integer)seed); return 1; }
pushq %rbx movq %rdi, %rbx callq 0x8f4d testl %eax, %eax jle 0x3018c movq %rbx, %rdi movl $0x1, %esi callq 0xe462 testl %eax, %eax movl $0x2f, %ecx cmovnel %eax, %ecx movl $0x400, %eax # imm = 0x400 movl %ecx, %edx shll $0xd, %edx xorl %ecx, %edx movl %edx, %esi shrl $0x11, %esi xorl %edx, %esi movl %esi, %ecx shll $0x5, %ecx xorl %esi, %ecx decl %eax jne 0x3016b movl %ecx, 0x1129be(%rip) # 0x142b48 jmp 0x30192 movl 0x1129b6(%rip), %ecx # 0x142b48 movl %ecx, %esi movq %rbx, %rdi callq 0xa4be movl $0x1, %eax popq %rbx retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_random
static int f_random(lua_State *L) { lua_Integer low, up; double r = (double)(px_rand() % 100000) / 100000.0; switch (lua_gettop(L)) { case 0: lua_pushnumber(L, (lua_Number)r); return 1; case 1: low = 1; up = luaL_checkinteger(L, 1); break; case 2: low = luaL_checkinteger(L, 1); up = luaL_checkinteger(L, 2); break; default: return luaL_error(L, "wrong number of arguments"); } luaL_argcheck(L, low <= up, 1, "interval is empty"); luaL_argcheck(L, low >= 0 || up <= LUA_MAXINTEGER + low, 1, "interval too large"); r *= (double)(up - low) + 1.0; lua_pushinteger(L, (lua_Integer)r + low); return 1; }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx pushq %rax movq %rdi, %rbx movl 0x112994(%rip), %eax # 0x142b48 movl %eax, %ecx shll $0xd, %ecx xorl %eax, %ecx movl %ecx, %eax shrl $0x11, %eax xorl %ecx, %eax movl %eax, %ecx shll $0x5, %ecx xorl %eax, %ecx movl %ecx, 0x112979(%rip) # 0x142b48 movl %ecx, %eax shrl $0x5, %eax imulq $0xa7c5ac5, %rax, %rax # imm = 0xA7C5AC5 shrq $0x27, %rax imull $0x186a0, %eax, %eax # imm = 0x186A0 subl %eax, %ecx cvtsi2sd %ecx, %xmm0 divsd 0x4b7d(%rip), %xmm0 # 0x34d70 movsd %xmm0, (%rsp) callq 0x8f4d movl %eax, %r15d cmpl $0x2, %eax je 0x30227 movq %r15, %r14 cmpl $0x1, %eax je 0x30237 testl %eax, %eax jne 0x302d2 movq %rbx, %rdi movsd (%rsp), %xmm0 callq 0xa4a9 jmp 0x302c1 movq %rbx, %rdi movl $0x1, %esi callq 0xe462 movq %rax, %r14 movq %rbx, %rdi movl %r15d, %esi callq 0xe462 movq %rax, %r15 movq %rax, %r12 subq %r14, %r12 jge 0x30261 leaq 0x3e3a(%rip), %rdx # 0x3408e movq %rbx, %rdi movl $0x1, %esi callq 0xdabf testq %r14, %r14 sets %al movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF addq %r14, %rcx cmpq %rcx, %r15 setg %cl andb %al, %cl cmpb $0x1, %cl jne 0x30295 leaq 0x3e18(%rip), %rdx # 0x340a0 movq %rbx, %rdi movl $0x1, %esi callq 0xdabf xorps %xmm0, %xmm0 cvtsi2sd %r12, %xmm0 addsd 0x2b3b(%rip), %xmm0 # 0x32de0 movsd (%rsp), %xmm1 mulsd %xmm0, %xmm1 cvttsd2si %xmm1, %rax addq %rax, %r14 movq %rbx, %rdi movq %r14, %rsi callq 0xa4be movl $0x1, %eax addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 retq leaq 0x3d9b(%rip), %rsi # 0x34074 movq %rbx, %rdi xorl %eax, %eax addq $0x8, %rsp popq %rbx popq %r12 popq %r14 popq %r15 jmp 0xdb8f
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_resolution
static int f_resolution(lua_State *L) { int width = (int)luaL_checkinteger(L, 1); int height = (int)luaL_checkinteger(L, 2); luaL_argcheck(L, width > 0 && width < PX_SCREEN_MAX_WIDTH, 1, "invalid width value"); luaL_argcheck(L, height > 0 && height < PX_SCREEN_MAX_HEIGHT, 2, "invalid height value"); px_create_texture(L, width, height); return 0; }
pushq %r15 pushq %r14 pushq %rbx movq %rdi, %rbx movl $0x1, %esi callq 0xe462 movq %rax, %r14 movq %rbx, %rdi movl $0x2, %esi callq 0xe462 movq %rax, %r15 leal -0x1(%r14), %eax cmpl $0x3ff, %eax # imm = 0x3FF jb 0x30386 leaq 0x51d9(%rip), %rdx # 0x35552 movq %rbx, %rdi movl $0x1, %esi callq 0xdabf leal -0x1(%r15), %eax cmpl $0x3ff, %eax # imm = 0x3FF jb 0x303a5 leaq 0x51ce(%rip), %rdx # 0x35566 movq %rbx, %rdi movl $0x2, %esi callq 0xdabf movq %rbx, %rdi movl %r14d, %esi movl %r15d, %edx callq 0x308c5 xorl %eax, %eax popq %rbx popq %r14 popq %r15 retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_compress
static int f_compress(lua_State *L) { size_t source_size; luaL_Buffer buffer; const char *source = luaL_checklstring(L, 1, &source_size); int dest_size = LZ4_compressBound((int)source_size); char *dest = luaL_buffinitsize(L, &buffer, dest_size); dest_size = LZ4_compress_default(source, dest, (int)source_size, dest_size); if (!dest_size) luaL_error(L, "compression failed"); luaL_pushresultsize(&buffer, dest_size); return 1; }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x2030, %rsp # imm = 0x2030 movq %rdi, %rbx leaq 0x8(%rsp), %r14 movl $0x1, %esi movq %r14, %rdx callq 0xe339 movq %rax, %r15 movl (%r14), %edi callq 0x293aa movslq %eax, %r12 leaq 0x10(%rsp), %rsi movq %rbx, %rdi movq %r12, %rdx callq 0xe83c movl (%r14), %edx movq %r15, %rdi movq %rax, %rsi movl %r12d, %ecx callq 0x7d1a movl %eax, %ebp testl %eax, %eax jne 0x30425 leaq 0x51ce(%rip), %rsi # 0x355e9 movq %rbx, %rdi xorl %eax, %eax callq 0xdb8f movslq %ebp, %rsi leaq 0x10(%rsp), %rdi callq 0xe780 movl $0x1, %eax addq $0x2030, %rsp # imm = 0x2030 popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_decompress
static int f_decompress(lua_State *L) { size_t source_size; luaL_Buffer buffer; const char *source = luaL_checklstring(L, 1, &source_size); int dest_size = (int)luaL_optinteger(L, 2, 64 * 1024); char *dest = luaL_buffinitsize(L, &buffer, dest_size); dest_size = LZ4_decompress_safe(source, dest, (int)source_size, dest_size); if (!dest_size) luaL_error(L, "decompression failed"); luaL_pushresultsize(&buffer, dest_size); return 1; }
pushq %rbp pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x2030, %rsp # imm = 0x2030 movq %rdi, %rbx leaq 0x8(%rsp), %r14 movl $0x1, %esi movq %r14, %rdx callq 0xe339 movq %rax, %r15 movl $0x10000, %edx # imm = 0x10000 movq %rbx, %rdi movl $0x2, %esi callq 0xe4bd movslq %eax, %r12 leaq 0x10(%rsp), %rsi movq %rbx, %rdi movq %r12, %rdx callq 0xe83c movl (%r14), %edx movq %r15, %rdi movq %rax, %rsi movl %r12d, %ecx callq 0x2b38b movl %eax, %ebp testl %eax, %eax jne 0x304bb leaq 0x5136(%rip), %rsi # 0x355e7 movq %rbx, %rdi xorl %eax, %eax callq 0xdb8f movslq %ebp, %rsi leaq 0x10(%rsp), %rdi callq 0xe780 movl $0x1, %eax addq $0x2030, %rsp # imm = 0x2030 popq %rbx popq %r12 popq %r14 popq %r15 popq %rbp retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_bind
static int f_bind(lua_State *L) { struct sockaddr_in sin; Uint16 port = (Uint16)luaL_checkinteger(L, 1); // prepare addr SDL_zero(sin); sin.sin_family = AF_INET; sin.sin_port = htons(port); sin.sin_addr.s_addr = htonl(INADDR_ANY); // bind socket net_create_socket(L); if (bind(socket_fd, (struct sockaddr*)&sin, sizeof(sin))) luaL_error(L, "Cannot bind on port %d", port); return 0; }
pushq %r15 pushq %r14 pushq %rbx subq $0x10, %rsp movq %rdi, %rbx movl $0x1, %esi callq 0xe462 movq %rax, %r14 movq %rsp, %r15 movl $0x10, %edx movq %r15, %rdi xorl %esi, %esi callq 0x6250 movw $0x2, (%r15) movl %r14d, %eax rolw $0x8, %ax movw %ax, 0x2(%r15) movl $0x0, 0x4(%r15) movq %rbx, %rdi callq 0x309eb movl 0x11261c(%rip), %edi # 0x142b4c movq %r15, %rsi movl $0x10, %edx callq 0x60f0 testl %eax, %eax je 0x30556 movzwl %r14w, %edx leaq 0x50b0(%rip), %rsi # 0x355fc movq %rbx, %rdi xorl %eax, %eax callq 0xdb8f xorl %eax, %eax addq $0x10, %rsp popq %rbx popq %r14 popq %r15 retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_unbind
static int f_unbind(lua_State *L) { (void)L; if (socket_fd != INVALID_SOCKET) { closesocket(socket_fd); socket_fd = INVALID_SOCKET; } return 0; }
movl 0x1125e4(%rip), %edi # 0x142b4c cmpl $-0x1, %edi je 0x30581 pushq %rax callq 0x6880 movl $0xffffffff, 0x1125cf(%rip) # imm = 0xFFFFFFFF addq $0x8, %rsp xorl %eax, %eax retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_recv
static int f_recv(lua_State *L) { struct sockaddr_in sin; int datalen = 1024 * 4; socklen_t sinlen; luaL_Buffer buffer; char *data; struct timeval tv; fd_set set; // check socket for data net_create_socket(L); FD_ZERO(&set); FD_SET(socket_fd, &set); tv.tv_sec = 0; tv.tv_usec = 0; if (select(socket_fd + 1, &set, NULL, NULL, &tv) <= 0) return 0; if (!FD_ISSET(socket_fd, &set)) return 0; // reset addr SDL_zero(sin); sin.sin_family = AF_INET; sin.sin_port = 0; sin.sin_addr.s_addr = INADDR_ANY; sinlen = sizeof(sin); // receive data = luaL_buffinitsize(L, &buffer, datalen); datalen = recvfrom(socket_fd, data, datalen, 0, (struct sockaddr*)&sin, &sinlen); if (datalen < 0) return 0; luaL_pushresultsize(&buffer, datalen); lua_pushinteger(L, ntohl(sin.sin_addr.s_addr)); lua_pushinteger(L, ntohs(sin.sin_port)); return 3; }
pushq %r15 pushq %r14 pushq %r12 pushq %rbx subq $0x20d8, %rsp # imm = 0x20D8 movq %rdi, %rbx callq 0x309eb xorps %xmm0, %xmm0 leaq 0x30(%rsp), %rsi movaps %xmm0, 0x70(%rsi) movaps %xmm0, 0x60(%rsi) movaps %xmm0, 0x50(%rsi) movaps %xmm0, 0x40(%rsi) movaps %xmm0, 0x30(%rsi) movaps %xmm0, 0x20(%rsi) movaps %xmm0, 0x10(%rsi) movaps %xmm0, (%rsi) movl 0x112585(%rip), %edi # 0x142b4c leal 0x3f(%rdi), %eax testl %edi, %edi cmovnsl %edi, %eax movl %eax, %edx andl $-0x40, %edx movl %edi, %ecx subl %edx, %ecx movl $0x1, %edx shlq %cl, %rdx sarl $0x6, %eax cltq orq %rdx, 0x30(%rsp,%rax,8) incl %edi leaq 0x20(%rsp), %r8 movaps %xmm0, (%r8) xorl %r14d, %r14d xorl %edx, %edx xorl %ecx, %ecx callq 0x6490 testl %eax, %eax jle 0x306c8 movl 0x11253d(%rip), %eax # 0x142b4c leal 0x3f(%rax), %ecx testl %eax, %eax cmovnsl %eax, %ecx sarl $0x6, %ecx movslq %ecx, %rcx movq 0x30(%rsp,%rcx,8), %rcx btq %rax, %rcx jae 0x306c8 leaq 0x10(%rsp), %r15 xorl %r14d, %r14d movl $0x10, %edx movq %r15, %rdi xorl %esi, %esi callq 0x6250 movq $0x2, (%r15) leaq 0xc(%rsp), %r12 movl $0x10, (%r12) leaq 0xb8(%rsp), %rsi movl $0x1000, %edx # imm = 0x1000 movq %rbx, %rdi callq 0xe83c movl 0x1124da(%rip), %edi # 0x142b4c movl $0x1000, %edx # imm = 0x1000 movq %rax, %rsi xorl %ecx, %ecx movq %r15, %r8 movq %r12, %r9 callq 0x6390 testl %eax, %eax js 0x306c8 andl $0x7fffffff, %eax # imm = 0x7FFFFFFF leaq 0xb8(%rsp), %rdi movq %rax, %rsi callq 0xe780 movl 0x14(%rsp), %esi bswapl %esi movq %rbx, %rdi callq 0xa4be movzwl 0x12(%rsp), %eax rolw $0x8, %ax movzwl %ax, %esi movq %rbx, %rdi callq 0xa4be movl $0x3, %r14d movl %r14d, %eax addq $0x20d8, %rsp # imm = 0x20D8 popq %rbx popq %r12 popq %r14 popq %r15 retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_send
static int f_send(lua_State *L) { struct sockaddr_in sin; size_t datalen; int sent; const char *data = luaL_checklstring(L, 1, &datalen); Uint32 host = (Uint32)luaL_checkinteger(L, 2); Uint16 port = (Uint16)luaL_checkinteger(L, 3); // prepare addr SDL_zero(sin); sin.sin_family = AF_INET; sin.sin_port = htons(port); sin.sin_addr.s_addr = htonl(host); // sned net_create_socket(L); sent = sendto(socket_fd, data, (int)datalen, 0, (struct sockaddr*)&sin, sizeof(sin)); lua_pushboolean(L, sent == (int)datalen); return 1; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movq %rdi, %rbx movq %rsp, %r14 movl $0x1, %esi movq %r14, %rdx callq 0xe339 movq %rax, %r15 movq %rbx, %rdi movl $0x2, %esi callq 0xe462 movq %rax, %r12 movq %rbx, %rdi movl $0x3, %esi callq 0xe462 movq %rax, %r13 leaq 0x8(%rsp), %rbp movl $0x10, %edx movq %rbp, %rdi xorl %esi, %esi callq 0x6250 rolw $0x8, %r13w movw $0x2, (%rbp) movw %r13w, 0x2(%rbp) bswapl %r12d movl %r12d, 0x4(%rbp) movq %rbx, %rdi callq 0x309eb movl 0x1123f5(%rip), %edi # 0x142b4c movslq (%r14), %rdx movq %r15, %rsi xorl %ecx, %ecx movq %rbp, %r8 movl $0x10, %r9d callq 0x6090 xorl %esi, %esi cmpl (%r14), %eax sete %sil movq %rbx, %rdi callq 0xad1e movl $0x1, %eax addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
f_resolve
static int f_resolve(lua_State *L) { struct addrinfo hints, *result; const char *hostname = luaL_checkstring(L, 1); SDL_zero(hints); hints.ai_family = AF_INET; if (getaddrinfo(hostname, NULL, &hints, &result) == 0) { if (result) { lua_pushinteger(L, ntohl(((struct sockaddr_in*)(result->ai_addr))->sin_addr.s_addr)); freeaddrinfo(result); return 1; } } lua_pushnil(L); lua_pushfstring(L, "cannot resolve " LUA_QS, hostname); return 2; }
pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x40, %rsp movq %rdi, %r14 movl $0x1, %ebx movl $0x1, %esi xorl %edx, %edx callq 0xe339 movq %rax, %r15 leaq 0x10(%rsp), %r12 movl $0x30, %edx movq %r12, %rdi xorl %esi, %esi callq 0x6250 movl $0x2, 0x4(%r12) leaq 0x8(%rsp), %r13 movq %r15, %rdi xorl %esi, %esi movq %r12, %rdx movq %r13, %rcx callq 0x6600 testl %eax, %eax sete %cl movq (%r13), %rax testq %rax, %rax setne %dl andb %cl, %dl cmpb $0x1, %dl jne 0x3081b movq 0x18(%rax), %rax movl 0x4(%rax), %esi bswapl %esi movq %r14, %rdi callq 0xa4be movq 0x8(%rsp), %rdi callq 0x6620 jmp 0x3083c movq %r14, %rdi callq 0xa495 leaq 0x4e02(%rip), %rsi # 0x3562c movq %r14, %rdi movq %r15, %rdx xorl %eax, %eax callq 0xab73 movl $0x2, %ebx movl %ebx, %eax addq $0x40, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
mml_reset_channel
static void mml_reset_channel(AudioChannel *channel) { if (channel->source) SDL_free((void*)channel->source); SDL_zerop(channel); channel->tempo = 140; channel->octave = 3; channel->waveform = PX_WAVEFORM_PULSE_50; channel->default_length = 4; }
pushq %rbx movq %rdi, %rbx movq (%rdi), %rdi testq %rdi, %rdi je 0x3085d callq 0x6280 movl $0x38, %edx movq %rbx, %rdi xorl %esi, %esi callq 0x6250 movabsq $0x30000008c, %rax # imm = 0x30000008C movq %rax, 0x28(%rbx) movl $0x3, 0x1c(%rbx) movl $0x4, 0x30(%rbx) popq %rbx retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
px_create_texture
static void px_create_texture(lua_State *L, int width, int height) { SDL_DisplayMode display_mode; // create new texture if (texture) SDL_DestroyTexture(texture); texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_STREAMING, width, height); if (!texture) luaL_error(L, "SDL_CreateTexture() failed: %s", SDL_GetError()); if (SDL_RenderSetLogicalSize(renderer, width, height)) luaL_error(L, "SDL_RenderSetLogicalSize() failed: %s", SDL_GetError()); screen_width = width; screen_height = height; // determine the best window size and center it if (SDL_GetDesktopDisplayMode(0, &display_mode)) luaL_error(L, "SDL_GetDesktopDisplayMode() failed: %s", SDL_GetError()); width = (display_mode.w - PX_WINDOW_PADDING) / screen_width; height = (display_mode.h - PX_WINDOW_PADDING) / screen_height; if (width < height) { height = screen_height * width; width = screen_width * width; } else { width = screen_width * height; height = screen_height * height; } SDL_SetWindowSize(window, width, height); SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED); }
pushq %rbp pushq %r14 pushq %rbx subq $0x20, %rsp movl %edx, %ebp movl %esi, %r14d movq %rdi, %rbx movq 0x11c04(%rip), %rdi # 0x424e0 testq %rdi, %rdi je 0x308e6 callq 0x6370 movq 0x11beb(%rip), %rdi # 0x424d8 movl $0x16462004, %esi # imm = 0x16462004 movl $0x1, %edx movl %r14d, %ecx movl %ebp, %r8d callq 0x6830 movq %rax, 0x11bd7(%rip) # 0x424e0 testq %rax, %rax jne 0x30927 callq 0x6380 leaq 0x4c61(%rip), %rsi # 0x3557b movq %rbx, %rdi movq %rax, %rdx xorl %eax, %eax callq 0xdb8f movq 0x11baa(%rip), %rdi # 0x424d8 movl %r14d, %esi movl %ebp, %edx callq 0x61e0 testl %eax, %eax je 0x30955 callq 0x6380 leaq 0x4c52(%rip), %rsi # 0x3559a movq %rbx, %rdi movq %rax, %rdx xorl %eax, %eax callq 0xdb8f movl %r14d, 0x111bac(%rip) # 0x142508 movl %ebp, 0x111baa(%rip) # 0x14250c leaq 0x8(%rsp), %rsi xorl %edi, %edi callq 0x6710 testl %eax, %eax je 0x3098b callq 0x6380 leaq 0x4c42(%rip), %rsi # 0x355c0 movq %rbx, %rdi movq %rax, %rdx xorl %eax, %eax callq 0xdb8f movl 0xc(%rsp), %eax movl 0x10(%rsp), %ecx addl $-0x20, %eax movl 0x111b6c(%rip), %edi # 0x142508 cltd idivl %edi movl %eax, %esi addl $-0x20, %ecx movl 0x111b61(%rip), %r8d # 0x14250c movl %ecx, %eax cltd idivl %r8d cmpl %eax, %esi cmovgel %eax, %esi imull %esi, %r8d imull %edi, %esi movq 0x11b0c(%rip), %rdi # 0x424d0 movl %r8d, %edx callq 0x6750 movq 0x11afd(%rip), %rdi # 0x424d0 movl $0x2fff0000, %esi # imm = 0x2FFF0000 movl $0x2fff0000, %edx # imm = 0x2FFF0000 callq 0x6080 addq $0x20, %rsp popq %rbx popq %r14 popq %rbp retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
px_audio_mixer_callback
static void px_audio_mixer_callback(void *userdata, Uint8 *stream, int len) { Sint8 *out, value; AudioChannel *channel; float v; int i, j, waveform; (void)userdata; for (i = 0, out = (Sint8*)stream; i < len; ++i) { value = 0; for (j = 0; j < PX_AUDIO_CHANNELS; ++j) { channel = &channels[j]; if (--channel->duration < 0) mml_parse_next(channel); if (channel->duration > channel->silence) waveform = channel->waveform; else waveform = PX_WAVEFORM_SILENCE; channel->t += 1.0f / mixing_frequency * channel->frequency; channel->t -= (int)channel->t; switch (waveform) { case PX_WAVEFORM_PULSE_12: value += channel->t <= 0.125f ? 4 : -4; break; case PX_WAVEFORM_PULSE_25: value += channel->t <= 0.25f ? 4 : -4; break; case PX_WAVEFORM_PULSE_50: value += channel->t <= 0.5f ? 4 : -4; break; case PX_WAVEFORM_SAWTOOTH: value += (Sint8)((-1.0f + channel->t * 2.0f) * 4.0f); break; case PX_WAVEFORM_TRIANLGE: if (channel->t < 0.25f) v = channel->t * 4.0f; else if (channel->t < 0.75f) v = 1.0f - ((channel->t - 0.25f) * 4.0f); else v = -1.0f + ((channel->t) - 0.75f) * 4.0f; value += (Sint8)(v * 8.0f); break; case PX_WAVEFORM_NOISE: value += audio_noise[(int)(channel->t * (float)PX_AUDIO_NOISE)]; break; } } *out++ = value; } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x18, %rsp movl %edx, 0x8(%rsp) testl %edx, %edx jle 0x30dec xorl %eax, %eax leaq 0x111a76(%rip), %r12 # 0x142510 leaq 0x430f(%rip), %r13 # 0x34db0 leaq 0x43f8(%rip), %rbx # 0x34ea0 movl %eax, 0xc(%rsp) movq %rsi, 0x10(%rsp) xorl %ebp, %ebp xorl %r14d, %r14d imulq $0x38, %rbp, %rax leaq (%r12,%rax), %r15 movl 0x20(%rax,%r12), %ecx leal -0x1(%rcx), %edx movl %edx, 0x20(%rax,%r12) testl %ecx, %ecx jle 0x30b61 movl 0x20(%r15), %eax cmpl 0x24(%r15), %eax jle 0x30b2f movl 0x1c(%r15), %eax movss 0x48b7(%rip), %xmm0 # 0x353a0 divss 0x111fdf(%rip), %xmm0 # 0x142ad0 mulss 0x18(%r15), %xmm0 addss 0x14(%r15), %xmm0 cvttps2dq %xmm0, %xmm1 cvtdq2ps %xmm1, %xmm1 subss %xmm1, %xmm0 movss %xmm0, 0x14(%r15) decl %eax cmpl $0x5, %eax ja 0x30d74 movslq (%rbx,%rax,4), %rax addq %rbx, %rax jmpq *%rax movss 0x48a2(%rip), %xmm1 # 0x353cc jmp 0x30ce3 movss 0x4869(%rip), %xmm0 # 0x353a0 divss 0x111f91(%rip), %xmm0 # 0x142ad0 mulss 0x18(%r15), %xmm0 addss 0x14(%r15), %xmm0 cvttps2dq %xmm0, %xmm1 cvtdq2ps %xmm1, %xmm1 subss %xmm1, %xmm0 movss %xmm0, 0x14(%r15) jmp 0x30d74 cmpq $0x0, 0x8(%r15) je 0x30ad3 movq %r15, %rdi callq 0x30e50 movq 0x8(%r15), %rcx leaq 0x1(%rcx), %rax movq %rax, 0x8(%r15) movzbl (%rcx), %edx leal -0x3c(%rdx), %esi cmpl $0x3b, %esi ja 0x30c23 movslq (%r13,%rsi,4), %rdx addq %r13, %rdx jmpq *%rdx movq %r15, %rdi callq 0x30e78 movl %eax, 0x30(%r15) jmp 0x30c78 movq %r15, %rdi callq 0x30e78 movl %eax, 0x28(%r15) jmp 0x30c78 movq %r15, %rdi callq 0x30e78 movl %eax, 0x2c(%r15) jmp 0x30c78 leaq 0x2(%rcx), %rax movq %rax, 0x8(%r15) movzbl 0x1(%rcx), %ecx cmpl $0x4d, %ecx jle 0x30c43 addl $-0x4e, %ecx cmpl $0x26, %ecx ja 0x30c7c movabsq $0x100000001, %rdx # imm = 0x100000001 btq %rcx, %rdx jb 0x30c66 movabsq $0x2000000020, %rdx # imm = 0x2000000020 btq %rcx, %rdx jb 0x30c5c movabsq $0x4000000040, %rdx # imm = 0x4000000040 btq %rcx, %rdx jae 0x30c7c movl $0x5, 0x1c(%r15) jmp 0x30c78 testl %edx, %edx jne 0x30c7c cmpl $0x0, 0x10(%r15) je 0x30c70 movq (%r15), %rax movq %rax, 0x8(%r15) jmp 0x30c7c incl 0x2c(%r15) jmp 0x30c78 decl 0x2c(%r15) jmp 0x30c78 cmpl $0x31, %ecx je 0x30c8a cmpl $0x32, %ecx je 0x30c94 cmpl $0x35, %ecx jne 0x30c7c movl $0x3, 0x1c(%r15) jmp 0x30c7c movl $0x4, 0x1c(%r15) jmp 0x30c78 movl $0x6, 0x1c(%r15) jmp 0x30c78 movq %r15, %rdi callq 0x3084c movq 0x8(%r15), %rax testq %rax, %rax jne 0x30b6c jmp 0x30ad3 movl $0x1, 0x1c(%r15) jmp 0x30c7c movl $0x2, 0x1c(%r15) jmp 0x30c7c movss 0x4702(%rip), %xmm1 # 0x353a8 ucomiss %xmm0, %xmm1 jbe 0x30d11 mulss 0x4701(%rip), %xmm0 # 0x353b4 jmp 0x30d65 movss 0x4708(%rip), %xmm1 # 0x353c8 jmp 0x30ce3 addss %xmm0, %xmm0 addss 0x46ea(%rip), %xmm0 # 0x353b8 mulss 0x46de(%rip), %xmm0 # 0x353b4 jmp 0x30d6d movss 0x46c5(%rip), %xmm1 # 0x353a8 ucomiss %xmm0, %xmm1 setae %al shlb $0x3, %al addb %r14b, %al addb $-0x4, %al movl %eax, %r14d jmp 0x30d74 mulss 0x46a6(%rip), %xmm0 # 0x353a4 cvttss2si %xmm0, %eax cltq leaq 0x1119c5(%rip), %rcx # 0x1426d0 addb (%rax,%rcx), %r14b jmp 0x30d74 movss 0x4693(%rip), %xmm1 # 0x353ac ucomiss %xmm0, %xmm1 jbe 0x30d4d addss 0x4696(%rip), %xmm0 # 0x353bc mulss 0x4692(%rip), %xmm0 # 0x353c0 addss 0x466a(%rip), %xmm0 # 0x353a0 jmp 0x30d65 movq %r15, %rdi callq 0x30ec8 movl 0x20(%r15), %eax movl %eax, 0x24(%r15) jmp 0x30ad3 addss 0x465b(%rip), %xmm0 # 0x353b0 mulss 0x4657(%rip), %xmm0 # 0x353b4 addss 0x4653(%rip), %xmm0 # 0x353b8 mulss 0x4657(%rip), %xmm0 # 0x353c4 cvttss2si %xmm0, %eax addb %al, %r14b incq %rbp cmpq $0x8, %rbp jne 0x30ab6 jmp 0x30dd1 movq %r15, %rdi movl $0x8, %esi jmp 0x30dc7 movq %r15, %rdi movl $0xd, %esi jmp 0x30dc7 movq %r15, %rdi movl $0x9, %esi jmp 0x30dc7 movq %r15, %rdi movl $0x4, %esi jmp 0x30dc7 movq %r15, %rdi movl $0x6, %esi jmp 0x30dc7 movq %r15, %rdi movl $0xb, %esi jmp 0x30dc7 movq %r15, %rdi movl $0xf, %esi callq 0x30f86 jmp 0x30ad3 movq 0x10(%rsp), %rsi movb %r14b, (%rsi) incq %rsi movl 0xc(%rsp), %eax incl %eax cmpl 0x8(%rsp), %eax jne 0x30aa8 addq $0x18, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
px_open_controllers
static void px_open_controllers(lua_State *L) { int i; SDL_GameController *controller; for (i = 0; i < SDL_NumJoysticks(); ++i) { if (SDL_IsGameController(i)) { controller = SDL_GameControllerOpen(i); if (!controller) luaL_error(L, "SDL_GameControllerOpen() failed: %s", SDL_GetError()); } } }
pushq %rbp pushq %r14 pushq %rbx movq %rdi, %rbx callq 0x6330 testl %eax, %eax jle 0x30e4b leaq 0x4958(%rip), %r14 # 0x3576a xorl %ebp, %ebp movl %ebp, %edi callq 0x6800 testl %eax, %eax je 0x30e40 movl %ebp, %edi callq 0x6450 testq %rax, %rax jne 0x30e40 callq 0x6380 movq %rbx, %rdi movq %r14, %rsi movq %rax, %rdx xorl %eax, %eax callq 0xdb8f incl %ebp callq 0x6330 cmpl %eax, %ebp jl 0x30e14 popq %rbx popq %r14 popq %rbp retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
mml_parse_number
static int mml_parse_number(AudioChannel *channel) { int value = 0; mml_skip_spaces(channel); while (SDL_isdigit(*channel->in)) { value *= 10; value += *channel->in++ - '0'; } return value; }
pushq %r14 pushq %rbx pushq %rax movq %rdi, %rbx callq 0x30e50 movq 0x8(%rbx), %rax movsbl (%rax), %edi callq 0x61c0 xorl %r14d, %r14d testl %eax, %eax je 0x30ebd leal (%r14,%r14,4), %eax movq 0x8(%rbx), %rcx leaq 0x1(%rcx), %rdx movq %rdx, 0x8(%rbx) movsbl (%rcx), %edx leal (%rdx,%rax,2), %r14d addl $-0x30, %r14d movsbl 0x1(%rcx), %edi callq 0x61c0 jmp 0x30e93 movl %r14d, %eax addq $0x8, %rsp popq %rbx popq %r14 retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
mml_parse_duration
static void mml_parse_duration(AudioChannel *channel) { float duration = (float)mml_parse_number(channel); if (duration == 0.0f) duration = (float)channel->default_length; duration = mixing_frequency / ((float)channel->tempo * 0.25f / 60.0f) * (1.0f / duration); if (mml_is_next(channel, '.')) duration *= 1.5f; channel->duration = (int)duration; if (mml_is_next(channel, '&')) channel->silence = 0; else channel->silence = (int)(duration * (1.0f / 8.0f)); }
pushq %rbx subq $0x10, %rsp movq %rdi, %rbx callq 0x30e78 testl %eax, %eax jne 0x30edc movl 0x30(%rbx), %eax cvtsi2ss %eax, %xmm0 cvtsi2ssl 0x28(%rbx), %xmm1 mulss 0x44bb(%rip), %xmm1 # 0x353a8 divss 0x44db(%rip), %xmm1 # 0x353d0 unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1] movss 0x111bd0(%rip), %xmm1 # 0x142ad0 movaps 0x44d9(%rip), %xmm2 # 0x353e0 unpcklps %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1] divps %xmm0, %xmm2 movaps %xmm2, %xmm0 shufps $0x55, %xmm2, %xmm0 # xmm0 = xmm0[1,1],xmm2[1,1] mulss %xmm2, %xmm0 movaps %xmm0, (%rsp) movq %rbx, %rdi callq 0x30e50 movq 0x8(%rbx), %rax cmpb $0x2e, (%rax) jne 0x30f42 incq %rax movq %rax, 0x8(%rbx) movaps (%rsp), %xmm0 mulss 0x4494(%rip), %xmm0 # 0x353d4 jmp 0x30f46 movaps (%rsp), %xmm0 movaps %xmm0, (%rsp) cvttss2si %xmm0, %eax movl %eax, 0x20(%rbx) movq %rbx, %rdi callq 0x30e50 movq 0x8(%rbx), %rax cmpb $0x26, (%rax) jne 0x30f6d incq %rax movq %rax, 0x8(%rbx) xorl %eax, %eax jmp 0x30f7d movaps (%rsp), %xmm0 mulss 0x4453(%rip), %xmm0 # 0x353cc cvttss2si %xmm0, %eax movl %eax, 0x24(%rbx) addq $0x10, %rsp popq %rbx retq
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
mml_parse_note
static void mml_parse_note(AudioChannel *channel, int key) { if (mml_is_next(channel, '#')) ++key; else if (mml_is_next(channel, '+')) ++key; else if (mml_is_next(channel, '-')) --key; key += (channel->octave - 1) * 12; channel->frequency = (float)SDL_pow(2.0, ((double)key - 49.0) / 12.0) * 440.0f; channel->t = 0.0f; mml_parse_duration(channel); }
pushq %rbp pushq %r14 pushq %rbx movl %esi, %r14d movq %rdi, %rbx callq 0x30e50 movq 0x8(%rbx), %rax movl $0x1, %ebp cmpb $0x23, (%rax) je 0x30fca movq %rbx, %rdi callq 0x30e50 movq 0x8(%rbx), %rax cmpb $0x2b, (%rax) je 0x30fca movq %rbx, %rdi callq 0x30e50 movq 0x8(%rbx), %rax movl $0xffffffff, %ebp # imm = 0xFFFFFFFF cmpb $0x2d, (%rax) jne 0x30fd4 incq %rax movq %rax, 0x8(%rbx) addl %ebp, %r14d movl 0x2c(%rbx), %eax leal (%rax,%rax,2), %eax leal (%r14,%rax,4), %eax addl $-0xc, %eax cvtsi2sd %eax, %xmm1 addsd 0x3d93(%rip), %xmm1 # 0x34d80 divsd 0x3d93(%rip), %xmm1 # 0x34d88 movsd 0x1e13(%rip), %xmm0 # 0x32e10 callq 0x6550 cvtsd2ss %xmm0, %xmm0 mulss 0x43ca(%rip), %xmm0 # 0x353d8 movss %xmm0, 0x18(%rbx) movl $0x0, 0x14(%rbx) movq %rbx, %rdi popq %rbx popq %r14 popq %rbp jmp 0x30ec8
/workspace/github_c_makefile_star2_O3/kieselsteini[P]PiXL-old/pixl.c
lt_process
void lt_process(const lt_global_t *g, bseq1_t s[2]) { int i, k, mlen; mlen = s[0].l_seq > s[1].l_seq? s[0].l_seq : s[1].l_seq; // trim heading and trailing N for (k = 0; k < 2; ++k) { bseq1_t *sk = &s[k]; for (i = sk->l_seq - 1; i >= 0; --i) // trim trailing "N" if (sk->seq[i] != 'N') break; sk->l_seq = i + 1; sk->seq[sk->l_seq] = sk->qual[sk->l_seq] = 0; for (i = 0; i < sk->l_seq; ++i) // trim heading "N" if (sk->seq[i] != 'N') break; if (i) trim_bseq_5(sk, i); } // trim Illumina PE adapters trim_adap(&s[0], lt_adapter1, 0, g->opt.min_adap_len, g->opt.max_adap_pen, 1); trim_adap(&s[1], lt_adapter2, 0, g->opt.min_adap_len, g->opt.max_adap_pen, 1); // trim transposon sequences and store barcodes int olig_pos[2]; char *bc[2]; for (k = 0; k < 2; ++k) { olig_pos[k] = 0; bc[k] = (char*)alloca(mlen + 1); bc[k][0] = 0; trim_olig(&s[k], lt_oligo_for, 1, g->opt.min_olig_len, g->opt.max_olig_pen, &olig_pos[k], bc[k], 1); trim_olig(&s[k], lt_oligo_rev, 0, g->opt.min_olig_len, g->opt.max_olig_pen, 0, 0, 0); trim_adap(&s[k], lt_oligo_rev, 0, g->opt.min_adap_len, g->opt.max_adap_pen, 1); } // merge the two ends int n_fh; uint64_t fh[2]; char *rseq, *rqual, *xseq, *xqual; rseq = (char*)alloca(mlen + 1); rqual = (char*)alloca(mlen + 1); xseq = (char*)alloca(s[0].l_seq + s[1].l_seq + 1); xqual = (char*)alloca(s[0].l_seq + s[1].l_seq + 1); // reverse the other read lt_seq_revcomp(s[1].l_seq, s[1].seq, rseq); lt_seq_rev(s[1].l_seq, s[1].qual, rqual); // find overlaps n_fh = lt_ue_for(s[0].l_seq, s[0].seq, s[0].qual, s[1].l_seq, rseq, rqual, g->opt.max_ovlp_pen, g->opt.min_ovlp_len, 2, fh); if (n_fh == 1) { int l = (uint32_t)fh[0], st = fh[0]>>32; if (st + l == s[0].l_seq) { // good stitch //printf("%s\n%s\n%s\n%s\n%d,%d,%d,%d\n",s[0].seq,s[0].qual,rseq,rqual,st,l,s[0].l_seq,s[1].l_seq); int x = 0; s[0].type = s[1].type = LT_MERGED; for (i = 0; i < st; ++i) xseq[x] = s[0].seq[i], xqual[x++] = s[0].qual[i]; for (i = 0; i < l; ++i) { int j = st + i, y; y = merge_base(g->opt.max_qual, s[0].seq[j], s[0].qual[j], rseq[i], rqual[i]); xseq[x] = (uint8_t)y, xqual[x++] = y>>8; } for (i = l; i < s[1].l_seq; ++i) xseq[x] = rseq[i], xqual[x++] = rqual[i]; //printf("%s\n%s\n%d\n",xseq,xqual,x); xseq[x] = xqual[x] = 0; free(s[0].seq); free(s[0].qual); s[0].seq = strdup(xseq); s[0].qual = strdup(xqual); s[0].l_seq = x; s[1].seq[0] = 0; s[1].l_seq = 0; } else { s[0].type = s[1].type = LT_NO_MERGE; } } else { s[0].type = s[1].type = LT_NO_MERGE; } // check whether read length is too short if (s[0].l_seq < g->opt.min_seq_len) { if (s[0].type == LT_MERGED) { // single-end s[0].type = s[1].type = LT_SHORT_SEQ; } else if (s[1].l_seq >= g->opt.min_seq_len) { // read 1 is short, but read 2 is not => swap char *tmp; tmp = s[0].seq, s[0].seq = s[1].seq, s[1].seq = tmp; tmp = s[0].qual, s[0].qual = s[1].qual, s[1].qual = tmp; tmp = bc[0], bc[0] = bc[1], bc[1] = tmp; i = olig_pos[0], olig_pos[0] = olig_pos[1], olig_pos[1] = i; i = s[0].l_seq, s[0].l_seq = s[1].l_seq, s[1].l_seq = i; s[0].type = s[1].type = LT_SHORT_PE_SWAP; } else { s[0].type = s[1].type = LT_SHORT_SEQ; } } else if (s[0].type != LT_MERGED && s[1].l_seq < g->opt.min_seq_len) { // read 2 is short, but read 1 is not s[0].type = s[1].type = LT_SHORT_PE; } // record the barcodes for (k = 0; k < 2; ++k) { s[k].olig_pos_f = olig_pos[0]; s[k].olig_pos_r = olig_pos[1]; s[k].bc_f = strdup(bc[0]); s[k].bc_r = strdup(bc[1]); } }
pushq %rbp movq %rsp, %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x118, %rsp # imm = 0x118 movq %rsi, %rbx movq %rdi, -0x58(%rbp) movl (%rsi), %eax movq %rax, -0x40(%rbp) movl $0x7fffffff, %eax # imm = 0x7FFFFFFF andl 0x38(%rsi), %eax movl %eax, -0x38(%rbp) movb $0x1, %r15b xorl %edi, %edi movl $0x7fffffff, %r13d # imm = 0x7FFFFFFF xorl %eax, %eax movq %rsi, -0x30(%rbp) imulq $0x38, %rax, %rax leaq (%rbx,%rax), %r14 movl (%rbx,%rax), %eax movl %eax, %edx andl $0x7fffffff, %edx # imm = 0x7FFFFFFF testq %rdx, %rdx jle 0x3114 leaq -0x1(%rdx), %rcx movq 0x18(%r14), %rsi cmpb $0x4e, -0x1(%rsi,%rdx) movq %rcx, %rdx je 0x30f3 incl %ecx andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF jmp 0x3116 xorl %ecx, %ecx andl $0x80000000, %eax # imm = 0x80000000 orl %ecx, %eax movl %eax, (%r14) movq 0x20(%r14), %rax movl %ecx, %ecx movb %dil, (%rax,%rcx) movq 0x18(%r14), %rax movl (%r14), %ecx andq %r13, %rcx movb %dil, (%rax,%rcx) movl (%r14), %eax andq %r13, %rax je 0x31c7 movq 0x18(%r14), %rcx xorl %r12d, %r12d cmpb $0x4e, (%rcx,%r12) jne 0x315d incq %r12 cmpq %r12, %rax jne 0x314b movl %eax, %r12d testl %r12d, %r12d je 0x31c7 movq 0x18(%r14), %rdi movl %r12d, %ebx leaq (%rdi,%rbx), %rsi subl %r12d, %eax movslq %eax, %rdx callq 0x21d0 movq 0x20(%r14), %rdi addq %rdi, %rbx movl (%r14), %edx andq %r13, %rdx movslq %r12d, %rax subq %rax, %rdx movq %rbx, %rsi movq -0x30(%rbp), %rbx callq 0x21d0 xorl %edi, %edi movl (%r14), %eax movl %eax, %ecx subl %r12d, %ecx andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF andl $0x80000000, %eax # imm = 0x80000000 orl %ecx, %eax movl %eax, (%r14) movq 0x20(%r14), %rax movb %dil, (%rax,%rcx) movq 0x18(%r14), %rax movl (%r14), %ecx andq %r13, %rcx movb %dil, (%rax,%rcx) movl $0x1, %eax testb $0x1, %r15b movl $0x0, %r15d jne 0x30e0 movl $0x7fffffff, %r15d # imm = 0x7FFFFFFF movq -0x40(%rbp), %rax andl %r15d, %eax movl -0x38(%rbp), %ecx cmpl %ecx, %eax cmovbel %ecx, %eax movq %rax, -0x40(%rbp) movq 0x3f54(%rip), %r13 # 0x7150 movq -0x58(%rbp), %rax movl 0x18(%rax), %ecx movq %rcx, -0x38(%rbp) movl 0x1c(%rax), %r12d movq %r13, %rdi callq 0x20c0 movl (%rbx), %r14d andl %r14d, %r15d movq 0x18(%rbx), %rsi movq 0x20(%rbx), %rdx leaq -0x140(%rbp), %r10 movl %r15d, %edi movq %rdx, -0x50(%rbp) movl %eax, %ecx movq %r13, %r8 xorl %r9d, %r9d pushq %r10 pushq $0x4 pushq %r12 pushq -0x38(%rbp) callq 0x29c5 addq $0x20, %rsp testl %eax, %eax jle 0x32ba decl %eax movq -0x140(%rbp,%rax,8), %rcx movq %rcx, %rax shrq $0x20, %rax subl %eax, %r15d cmpl %r12d, %r15d jle 0x329e movl %eax, %ecx andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF andl $0x80000000, %r14d # imm = 0x80000000 orl %ecx, %r14d movq -0x30(%rbp), %rbx movl %r14d, (%rbx) movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF andq %rcx, %rax xorl %edx, %edx movq -0x50(%rbp), %rsi movb %dl, (%rsi,%rax) movq 0x18(%rbx), %rax movl (%rbx), %esi andq %rcx, %rsi movb %dl, (%rax,%rsi) jmp 0x32ba sarq $0x20, %rcx movq -0x50(%rbp), %rdi addq %rcx, %rdi movslq %r15d, %rdx movl $0x22, %esi callq 0x2110 movq -0x30(%rbp), %rbx movq 0x3e97(%rip), %r13 # 0x7158 movq -0x58(%rbp), %rax movl 0x18(%rax), %ecx movq %rcx, -0x38(%rbp) movl 0x1c(%rax), %r15d movq %r13, %rdi callq 0x20c0 movl 0x38(%rbx), %r14d movl %r14d, %r12d andl $0x7fffffff, %r12d # imm = 0x7FFFFFFF movq 0x50(%rbx), %rsi movq 0x58(%rbx), %rcx movq %r15, %rbx movq %rcx, %r15 movl %r12d, %edi movq %rcx, %rdx movl %eax, %ecx movq %r13, %r8 xorl %r9d, %r9d leaq -0x140(%rbp), %rax pushq %rax pushq $0x4 pushq %rbx pushq -0x38(%rbp) callq 0x29c5 addq $0x20, %rsp testl %eax, %eax jle 0x3384 decl %eax movq -0x140(%rbp,%rax,8), %rcx movq %rcx, %rax shrq $0x20, %rax subl %eax, %r12d cmpl %ebx, %r12d jle 0x336d movl %eax, %ecx andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF andl $0x80000000, %r14d # imm = 0x80000000 orl %ecx, %r14d movq -0x30(%rbp), %rsi movl %r14d, 0x38(%rsi) movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF andq %rcx, %rax xorl %edx, %edx movb %dl, (%r15,%rax) movq 0x50(%rsi), %rax movl 0x38(%rsi), %esi andq %rcx, %rsi movb %dl, (%rax,%rsi) jmp 0x3384 sarq $0x20, %rcx addq %rcx, %r15 movslq %r12d, %rdx movq %r15, %rdi movl $0x22, %esi callq 0x2110 movq -0x40(%rbp), %rcx incl %ecx leaq -0x70(%rbp), %rsi leaq -0xb0(%rbp), %rax movb $0x1, %dl movq %rcx, -0x40(%rbp) addl $0xf, %ecx andl $-0x10, %ecx movq %rcx, -0x88(%rbp) xorl %ecx, %ecx movq -0x30(%rbp), %rbx movl %edx, -0x50(%rbp) movq %rsi, -0x98(%rbp) movl $0x0, (%rsi) movq %rsp, %r15 subq -0x88(%rbp), %r15 movq %r15, %rsp movq %r15, (%rax) movb $0x0, (%r15) imulq $0x38, %rcx, %r13 leaq (%rbx,%r13), %rax movq %rax, -0x38(%rbp) movq 0x3d7b(%rip), %r14 # 0x7160 movq -0x58(%rbp), %rax movl 0x20(%rax), %ecx movq %rcx, -0x48(%rbp) movl 0x24(%rax), %r12d movq %r14, %rdi callq 0x20c0 movq %rbx, %rcx movl (%rbx,%r13), %ebx movl $0x7fffffff, %edx # imm = 0x7FFFFFFF andl %edx, %ebx movq 0x18(%rcx,%r13), %rsi movq 0x20(%rcx,%r13), %r13 movl %ebx, %edi movq %rsi, -0x90(%rbp) movq %r13, %rdx movl %eax, %ecx movq %r14, %r8 xorl %r9d, %r9d leaq -0x140(%rbp), %rax pushq %rax pushq $0x10 movq %r12, -0x68(%rbp) pushq %r12 pushq -0x48(%rbp) movq -0x38(%rbp), %r12 callq 0x2ab8 addq $0x20, %rsp testl %eax, %eax jle 0x350d movq %r13, %rdi decl %eax movq -0x140(%rbp,%rax,8), %r14 movq %r14, %rax shrq $0x20, %rax subl %eax, %ebx movslq %ebx, %r13 cmpl -0x68(%rbp), %ebx jle 0x3500 movq %r15, %rdi movq -0x90(%rbp), %rbx movq %rbx, %rsi movq %r13, %rdx callq 0x2070 xorl %eax, %eax movb %al, (%r15,%r13) xorl %r15d, %r15d movq -0x98(%rbp), %rax movl %r13d, (%rax) leaq (%rbx,%r13), %rsi sarq $0x20, %r14 movq %rbx, %rdi movq %r14, %rdx callq 0x21d0 movq 0x20(%r12), %rdi leaq (%rdi,%r13), %rsi movl (%r12), %edx movl $0x7fffffff, %r14d # imm = 0x7FFFFFFF andq %r14, %rdx subq %r13, %rdx callq 0x21d0 movl (%r12), %eax movl %eax, %ecx subl %r13d, %ecx andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF andl $0x80000000, %eax # imm = 0x80000000 orl %ecx, %eax movl %eax, (%r12) movq 0x20(%r12), %rax movb %r15b, (%rax,%rcx) movq 0x18(%r12), %rax movl (%r12), %ecx andq %r14, %rcx movb %r15b, (%rax,%rcx) jmp 0x350d movl $0x22, %esi movq %r13, %rdx callq 0x2110 movq 0x3c54(%rip), %rbx # 0x7168 movq -0x58(%rbp), %rax movl 0x20(%rax), %ecx movq %rcx, -0x48(%rbp) movl 0x24(%rax), %r15d movq %rbx, %rdi callq 0x20c0 movl (%r12), %r13d movl %r13d, %r14d andl $0x7fffffff, %r14d # imm = 0x7FFFFFFF movq 0x18(%r12), %rsi movq 0x20(%r12), %rdx movl %r14d, %edi movq %rdx, -0x68(%rbp) movl %eax, %ecx movq %rbx, %r8 xorl %r9d, %r9d leaq -0x140(%rbp), %rax pushq %rax pushq $0x10 pushq %r15 pushq -0x48(%rbp) callq 0x29c5 addq $0x20, %rsp testl %eax, %eax jle 0x35d7 decl %eax movq -0x140(%rbp,%rax,8), %rcx movq %rcx, %rax shrq $0x20, %rax subl %eax, %r14d cmpl %r15d, %r14d jle 0x35bf movl %eax, %ecx andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF andl $0x80000000, %r13d # imm = 0x80000000 orl %ecx, %r13d movl %r13d, (%r12) movl $0x7fffffff, %esi # imm = 0x7FFFFFFF andq %rsi, %rax xorl %edx, %edx movq -0x68(%rbp), %rcx movb %dl, (%rcx,%rax) movq 0x18(%r12), %rax movl (%r12), %ecx andq %rsi, %rcx movb %dl, (%rax,%rcx) jmp 0x35d7 sarq $0x20, %rcx movq -0x68(%rbp), %rdi addq %rcx, %rdi movslq %r14d, %rdx movl $0x22, %esi callq 0x2110 movq 0x3b8a(%rip), %rbx # 0x7168 movq -0x58(%rbp), %rax movl 0x18(%rax), %ecx movq %rcx, -0x48(%rbp) movl 0x1c(%rax), %r15d movq %rbx, %rdi callq 0x20c0 movl (%r12), %r13d movl %r13d, %r14d andl $0x7fffffff, %r14d # imm = 0x7FFFFFFF movq 0x18(%r12), %rsi movq 0x20(%r12), %rcx movq %r15, %r12 movq %rcx, %r15 movl %r14d, %edi movq %rcx, %rdx movl %eax, %ecx movq %rbx, %r8 xorl %r9d, %r9d leaq -0x140(%rbp), %rax pushq %rax pushq $0x4 pushq %r12 pushq -0x48(%rbp) callq 0x29c5 addq $0x20, %rsp testl %eax, %eax movq -0x30(%rbp), %rbx jle 0x36a6 decl %eax movq -0x140(%rbp,%rax,8), %rcx movq %rcx, %rax shrq $0x20, %rax subl %eax, %r14d cmpl %r12d, %r14d jle 0x368f movl %eax, %ecx andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF andl $0x80000000, %r13d # imm = 0x80000000 orl %ecx, %r13d movq -0x38(%rbp), %rcx movl %r13d, (%rcx) movl $0x7fffffff, %esi # imm = 0x7FFFFFFF andq %rsi, %rax xorl %edx, %edx movb %dl, (%r15,%rax) movq 0x18(%rcx), %rax movl (%rcx), %ecx andq %rsi, %rcx movb %dl, (%rax,%rcx) jmp 0x36a6 sarq $0x20, %rcx addq %rcx, %r15 movslq %r14d, %rdx movq %r15, %rdi movl $0x22, %esi callq 0x2110 movl $0x1, %ecx leaq -0xa8(%rbp), %rax leaq -0x6c(%rbp), %rsi testb $0x1, -0x50(%rbp) movl $0x0, %edx jne 0x33ae movq %rsp, %r15 movq -0x40(%rbp), %rax addl $0xf, %eax andl $-0x10, %eax subq %rax, %r15 movq %r15, %rsp movq %rsp, %r9 subq %rax, %r9 movq %r9, %rsp movl (%rbx), %eax movq %rbx, %rsi movl 0x38(%rbx), %ebx movl %eax, -0x48(%rbp) movl %eax, %r14d andl $0x7fffffff, %r14d # imm = 0x7FFFFFFF movl %ebx, %ecx andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF leal (%r14,%rcx), %eax addl $0x10, %eax andl $-0x10, %eax movq %rsp, %r13 subq %rax, %r13 movq %r13, %rsp movq %rsp, %rdx subq %rax, %rdx movq %rdx, -0x40(%rbp) movq %rdx, %rsp testq %rcx, %rcx je 0x3774 movq 0x50(%rsi), %rax leaq 0x3a42(%rip), %r8 # 0x7170 movq %rcx, %rdx movsbq (%rax), %rsi testq %rsi, %rsi js 0x3740 movb (%rsi,%r8), %sil jmp 0x3743 movb $0x4e, %sil movb %sil, -0x1(%r15,%rdx) incq %rax decq %rdx jne 0x3731 movb $0x0, (%r15,%rcx) movq -0x30(%rbp), %rax movq 0x58(%rax), %rax movq %rcx, %rsi movb (%rax), %dl movb %dl, -0x1(%r9,%rsi) incq %rax decq %rsi jne 0x3760 movq %rcx, %rax jmp 0x377a movb $0x0, (%r15) xorl %eax, %eax movb $0x0, (%r9,%rax) movq -0x30(%rbp), %r12 movq 0x18(%r12), %rsi movq 0x20(%r12), %rdx movq -0x58(%rbp), %r8 movl 0x10(%r8), %eax movl 0x14(%r8), %r10d movl %r14d, %edi movq %rsi, -0x80(%rbp) movq %rdx, -0x38(%rbp) movq %rcx, -0xc0(%rbp) movq %r15, %r8 movq %r9, -0x50(%rbp) leaq -0x140(%rbp), %r11 pushq %r11 pushq $0x2 pushq %r10 pushq %rax callq 0x29c5 addq $0x20, %rsp cmpl $0x1, %eax jne 0x3820 movq -0x140(%rbp), %rcx movq %rcx, %r12 shrq $0x20, %r12 leal (%r12,%rcx), %eax cmpl %r14d, %eax jne 0x3827 movl $0x15, %eax movq -0x30(%rbp), %rbx movl %eax, 0x3c(%rbx) movl %eax, 0x4(%rbx) testl %r12d, %r12d jle 0x383f movq %r13, %rdi movq -0x80(%rbp), %rsi movq %r12, %rdx movq %rcx, %r14 callq 0x2150 movq -0x40(%rbp), %rdi movq -0x38(%rbp), %rsi movq %r12, %rdx callq 0x2150 movq %r14, %rcx jmp 0x3842 movl $0x16, %eax jmp 0x3830 movl $0x16, %eax movq -0x30(%rbp), %r12 movl %eax, 0x3c(%r12) movl %eax, 0x4(%r12) jmp 0x3aff xorl %r12d, %r12d movq -0x50(%rbp), %r8 testl %ecx, %ecx jle 0x3988 movq %rcx, %rax sarq $0x20, %rax movl %r12d, %r12d movq %rcx, -0x78(%rbp) andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF movq %rcx, -0x48(%rbp) movq -0x40(%rbp), %rcx addq %r12, %rcx movq %rcx, -0x68(%rbp) movq %r13, -0xb8(%rbp) movq %r12, -0x60(%rbp) leaq (%r13,%r12), %rcx movq %rcx, -0x90(%rbp) movq -0x80(%rbp), %rcx addq %rax, %rcx movq %rcx, -0x88(%rbp) addq %rax, -0x38(%rbp) xorl %ecx, %ecx movq %r15, -0x98(%rbp) movq -0x88(%rbp), %rax movsbq (%rax,%rcx), %r12 movq -0x38(%rbp), %rax movzbl (%rax,%rcx), %ebx movsbq (%r15,%rcx), %r13 movq %rcx, %r15 movzbl (%r8,%rcx), %r14d cmpb %r13b, %r12b jne 0x3911 movq -0x58(%rbp), %rax movl 0xc(%rax), %r13d cmpb %r14b, %bl movl %r14d, %eax cmovgl %ebx, %eax cmovll %ebx, %r14d movsbl %al, %eax movsbl %r14b, %ecx leal -0x21(%rcx), %edx movzwl %dx, %edx shrl $0xf, %edx addl %edx, %ecx addl $-0x21, %ecx sarl %ecx leal (%rax,%rcx), %ebx addl $-0x21, %ebx callq 0x2030 cmpl %r13d, %ebx jl 0x3908 movl %r13d, %ebx shlq $0x2, %r12 addq (%rax), %r12 jmp 0x3931 callq 0x2030 movq (%rax), %rax cmpb %r14b, %bl jle 0x3927 leaq (%rax,%r12,4), %r12 subl %r14d, %ebx jmp 0x3931 leaq (%rax,%r13,4), %r12 subl %ebx, %r14d movl %r14d, %ebx movq -0x50(%rbp), %r8 movq %r15, %rcx movl (%r12), %eax shll $0x8, %ebx addl $0x2100, %ebx # imm = 0x2100 orl %eax, %ebx movq -0x90(%rbp), %rdx movb %al, (%rdx,%r15) movq -0x68(%rbp), %rax movb %bh, (%rax,%rcx) incq %rcx cmpq %rcx, -0x48(%rbp) movq -0x98(%rbp), %r15 jne 0x38a3 movq -0x60(%rbp), %rax addl %ecx, %eax movq %rax, -0x60(%rbp) movq -0x30(%rbp), %rbx movq -0xb8(%rbp), %r13 movq -0x78(%rbp), %rcx jmp 0x398c movq %r12, -0x60(%rbp) movq -0xc0(%rbp), %r12 cmpl %ecx, %r12d jle 0x3a84 movl -0x60(%rbp), %ebx leaq (%rbx,%r13), %rdi movslq %ecx, %r14 addq %r14, %r15 notl %ecx addl %r12d, %ecx incq %rcx movq %rcx, -0x78(%rbp) movq %r15, %rsi movq %rcx, %rdx movq %r8, %r15 callq 0x2150 addq -0x40(%rbp), %rbx addq %r14, %r15 movq %rbx, %rdi movq %r15, %rsi movq -0x78(%rbp), %rdx callq 0x2150 movl %r12d, %ecx subq %r14, %rcx leaq 0x1(%rcx), %rax andq $-0x2, %rax decq %rcx movd -0x60(%rbp), %xmm0 movq %rcx, %xmm1 pshufd $0x44, %xmm1, %xmm2 # xmm2 = xmm1[0,1,0,1] movl $0x2, %ecx pcmpeqd %xmm3, %xmm3 movdqa %xmm0, %xmm1 psubq %xmm3, %xmm0 leaq (%rax,%rcx), %rdx addq $-0x2, %rdx addq $-0x2, %rcx cmpq $0x2, %rdx jne 0x3a02 negq %rcx movq %rcx, %xmm3 pshufd $0x44, %xmm3, %xmm3 # xmm3 = xmm3[0,1,0,1] por 0x160f(%rip), %xmm3 # 0x5040 movdqa 0x1617(%rip), %xmm4 # 0x5050 pxor %xmm4, %xmm2 pxor %xmm4, %xmm3 movdqa %xmm3, %xmm4 pcmpgtd %xmm2, %xmm4 pshufd $0xa0, %xmm4, %xmm5 # xmm5 = xmm4[0,0,2,2] pcmpeqd %xmm2, %xmm3 pshufd $0xf5, %xmm3, %xmm2 # xmm2 = xmm3[1,1,3,3] pand %xmm5, %xmm2 pshufd $0xf5, %xmm4, %xmm3 # xmm3 = xmm4[1,1,3,3] por %xmm2, %xmm3 pand %xmm3, %xmm1 pandn %xmm0, %xmm3 por %xmm1, %xmm3 pshufd $0xee, %xmm3, %xmm0 # xmm0 = xmm3[2,3,2,3] paddq %xmm3, %xmm0 movd %xmm0, %r12d movq -0x30(%rbp), %rbx jmp 0x3a88 movq -0x60(%rbp), %r12 movl %r12d, %eax xorl %r14d, %r14d movq -0x40(%rbp), %r15 movb %r14b, (%r15,%rax) movb %r14b, (%r13,%rax) movq -0x80(%rbp), %rdi callq 0x2050 movq 0x20(%rbx), %rdi callq 0x2050 movq %r13, %rdi callq 0x2240 movq %rax, 0x18(%rbx) movq %r15, %rdi callq 0x2240 movq %rax, 0x20(%rbx) movq %r12, %rcx movq %rbx, %r12 movl $0x80000000, %ebx # imm = 0x80000000 movl (%r12), %eax andl %ebx, %eax orl %ecx, %eax movl %eax, (%r12) movq 0x50(%r12), %rax movb %r14b, (%rax) andl 0x38(%r12), %ebx movl %ebx, 0x38(%r12) movl (%r12), %eax movl %eax, -0x48(%rbp) movl %eax, %r14d andl $0x7fffffff, %r14d # imm = 0x7FFFFFFF movq -0x58(%rbp), %rax movl 0x8(%rax), %ecx movl 0x4(%r12), %edx cmpl %ecx, %r14d jge 0x3b79 movl $0x2, %eax cmpl $0x15, %edx je 0x3b8d movl %ebx, %edx andl $0x7fffffff, %edx # imm = 0x7FFFFFFF cmpl %ecx, %edx jb 0x3b8d movq -0x30(%rbp), %rcx movups 0x18(%rcx), %xmm0 movdqu 0x50(%rcx), %xmm1 movdqu %xmm1, 0x18(%rcx) movups %xmm0, 0x50(%rcx) pshufd $0x4e, -0xb0(%rbp), %xmm0 # xmm0 = mem[2,3,0,1] movdqa %xmm0, -0xb0(%rbp) movq -0x70(%rbp), %xmm0 pshufd $0xe1, %xmm0, %xmm0 # xmm0 = xmm0[1,0,2,3] movq %xmm0, -0x70(%rbp) movl $0x80000000, %eax # imm = 0x80000000 movl -0x48(%rbp), %edi andl %eax, %edi orl %edi, %edx movl %edx, (%rcx) andl %eax, %ebx orl %r14d, %ebx movl %ebx, 0x38(%rcx) movl $0x4, %eax jmp 0x3b8d cmpl $0x15, %edx je 0x3b97 andl $0x7fffffff, %ebx # imm = 0x7FFFFFFF movl $0x3, %eax cmpl %ecx, %ebx jge 0x3b97 movq -0x30(%rbp), %rcx movl %eax, 0x3c(%rcx) movl %eax, 0x4(%rcx) movq -0x70(%rbp), %r15 movq -0xb0(%rbp), %rbx movq -0xa8(%rbp), %r14 movq -0x30(%rbp), %r12 movq %r15, 0x8(%r12) movq %rbx, %rdi callq 0x2240 movq %rax, 0x28(%r12) movq %r14, %rdi callq 0x2240 movq %rax, 0x30(%r12) movq %r15, 0x40(%r12) movq %rbx, %rdi callq 0x2240 movq %rax, 0x60(%r12) movq %r14, %rdi callq 0x2240 movq %rax, 0x68(%r12) leaq -0x28(%rbp), %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq
/workspace/github_c_makefile_star2_O3/lh3[P]pre-pe/pre-dip-c.c
main
int main(int argc, char *argv[]) { int c; lt_global_t g; gzFile fp; lt_global_init(&g); while ((c = getopt(argc, argv, "Tt:b:l:")) >= 0) { if (c == 't') g.opt.n_threads = atoi(optarg); else if (c == 'T') g.opt.tab_out = 1; else if (c == 'l') g.opt.min_seq_len = atoi(optarg); } if (argc - optind < 1) { fprintf(stderr, "Usage: seqtk mergepe <read1.fq> <read2.fq> | pre-dip-c [options] -\n"); fprintf(stderr, "Options:\n"); fprintf(stderr, " -t INT number of threads [%d]\n", g.opt.n_threads); fprintf(stderr, " -l INT min read/fragment length to output [%d]\n", g.opt.min_seq_len); fprintf(stderr, " -T tabular output for debugging\n"); return 1; } fp = strcmp(argv[optind], "-")? gzopen(argv[optind], "r") : gzdopen(fileno(stdin), "r"); g.ks = kseq_init(fp); kt_pipeline(2, worker_pipeline, &g, 3); kseq_destroy(g.ks); gzclose(fp); return 0; }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x38, %rsp movq %rsi, %rbx movl %edi, %ebp xorps %xmm0, %xmm0 movups %xmm0, 0x28(%rsp) movl $0x989680, 0x4(%rsp) # imm = 0x989680 movaps 0x143c(%rip), %xmm0 # 0x5060 movups %xmm0, 0xc(%rsp) movabsq $0x200000003, %rax # imm = 0x200000003 movq %rax, 0x1c(%rsp) movl $0xa, 0x24(%rsp) leaq 0x14af(%rip), %rdx # 0x50f6 callq 0x2200 testl %eax, %eax js 0x3cb6 movl $0x2, %r15d xorl %r13d, %r13d movl $0x28, %r14d leaq 0x1490(%rip), %r12 # 0x50f6 cmpl $0x54, %eax je 0x3c9d cmpl $0x6c, %eax je 0x3c89 cmpl $0x74, %eax jne 0x3ca3 movq 0x335c(%rip), %rax # 0x6fd8 movq (%rax), %rdi callq 0x2210 movl %eax, %r15d jmp 0x3ca3 movq 0x3348(%rip), %rax # 0x6fd8 movq (%rax), %rdi callq 0x2210 movl %eax, %r14d jmp 0x3ca3 movl $0x1, %r13d movl %ebp, %edi movq %rbx, %rsi movq %r12, %rdx callq 0x2200 testl %eax, %eax jns 0x3c66 jmp 0x3cc5 movl $0x28, %r14d xorl %r13d, %r13d movl $0x2, %r15d movl %r14d, 0x8(%rsp) movl %r13d, 0x28(%rsp) movl %r15d, (%rsp) movq 0x32f6(%rip), %rax # 0x6fd0 movslq (%rax), %rax cmpl %ebp, %eax jge 0x3df2 movq (%rbx,%rax,8), %rdi cmpb $0x2d, (%rdi) jne 0x3cf8 cmpb $0x0, 0x1(%rdi) je 0x3dd0 leaq 0x14d3(%rip), %rsi # 0x51d2 callq 0x21e0 movq %rax, %rbx movl $0x1, %edi movl $0x50, %esi callq 0x2120 movq %rax, %r14 movl $0x1, %edi movl $0x20, %esi callq 0x2120 movq %rax, %r15 movq %rbx, 0x10(%rax) movl $0x10000, 0x8(%rax) # imm = 0x10000 movl $0x4000, %edi # imm = 0x4000 callq 0x21a0 movq %rax, 0x18(%r15) movq %r15, 0x48(%r14) movq %rsp, %r15 movq %r14, 0x30(%r15) leaq 0xae(%rip), %rsi # 0x3e04 movl $0x2, %edi movq %r15, %rdx movl $0x3, %ecx callq 0x25b0 movq 0x30(%r15), %r14 testq %r14, %r14 je 0x3db7 movq 0x8(%r14), %rdi callq 0x2050 movq 0x18(%r14), %rdi callq 0x2050 movq 0x28(%r14), %rdi callq 0x2050 movq 0x38(%r14), %rdi callq 0x2050 movq 0x48(%r14), %r15 testq %r15, %r15 je 0x3daf movq 0x18(%r15), %rdi callq 0x2050 movq %r15, %rdi callq 0x2050 movq %r14, %rdi callq 0x2050 movq %rbx, %rdi callq 0x2040 xorl %eax, %eax addq $0x38, %rsp popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movq 0x31f1(%rip), %rax # 0x6fc8 movq (%rax), %rdi callq 0x2160 leaq 0x13ec(%rip), %rsi # 0x51d2 movl %eax, %edi callq 0x20a0 jmp 0x3d04 movl %r15d, %edi movl %r14d, %esi callq 0x2290 movl $0x1, %eax jmp 0x3dc1
/workspace/github_c_makefile_star2_O3/lh3[P]pre-pe/pre-dip-c.c
check_functions
static void check_functions( parasail_function_group_t f, parasail_sequences_t *sequences, unsigned long pair_limit_, const parasail_matrix_t *matrix_, gap_score_t gap) { const parasail_function_info_t *functions = f.fs; unsigned long matrix_index = 0; unsigned long gap_index = 0; unsigned long function_index = 0; long long pair_index = 0; long long pair_limit = (long long)pair_limit_; parasail_function_t *reference_function = NULL; const parasail_matrix_t ** matrices = parasail_matrices; const parasail_matrix_t * single_matrix[] = { matrix_, NULL }; if (NULL != matrix_) { matrices = single_matrix; } printf("checking %s functions\n", f.name); for (matrix_index=0; NULL!=matrices[matrix_index]; ++matrix_index) { const parasail_matrix_t *matrix = matrices[matrix_index]; const char *matrixname = matrix->name; if (verbose) printf("\t%s\n", matrixname); for (gap_index=0; INT_MIN!=gap_scores[gap_index].open; ++gap_index) { int open = gap_scores[gap_index].open; int extend = gap_scores[gap_index].extend; if (gap.open != INT_MIN && gap.extend != INT_MIN) { open = gap.open; extend = gap.extend; } if (verbose) printf("\t\topen=%d extend=%d\n", open, extend); reference_function = functions[0].pointer; for (function_index=1; NULL!=functions[function_index].pointer; ++function_index) { unsigned long saturated = 0; if (verbose) printf("\t\t\t%s\n", functions[function_index].name); #pragma omp parallel for for (pair_index=0; pair_index<pair_limit; ++pair_index) { parasail_result_t *reference_result = NULL; parasail_result_t *result = NULL; unsigned long a = 0; unsigned long b = 1; int *ref_score_table = NULL; int *score_table = NULL; size_t size_a = 0; size_t size_b = 0; k_combination2(pair_index, &a, &b); size_a = sequences->seqs[a].seq.l; size_b = sequences->seqs[b].seq.l; /*if (verbose) printf("\t\t\t\tpair=%lld (%lu,%lu)\n", pair_index, a, b);*/ reference_result = reference_function( sequences->seqs[a].seq.s, size_a, sequences->seqs[b].seq.s, size_b, open, extend, matrix); result = functions[function_index].pointer( sequences->seqs[a].seq.s, size_a, sequences->seqs[b].seq.s, size_b, open, extend, matrix); if (parasail_result_is_saturated(result)) { /* no point in comparing a result that saturated */ parasail_result_free(reference_result); parasail_result_free(result); #pragma omp atomic saturated += 1; continue; } ref_score_table = parasail_result_get_score_table(reference_result); score_table = parasail_result_get_score_table(result); if (reference_result->score != result->score) { #pragma omp critical(printer) { printf("%s(%lu,%lu,%d,%d,%s) wrong score (%d!=%d)\n", functions[function_index].name, a, b, open, extend, matrixname, reference_result->score, result->score); if (exit_on_mismatch) exit(EXIT_FAILURE); } } if (reference_result->end_query != result->end_query) { #pragma omp critical(printer) { printf("%s(%lu,%lu,%d,%d,%s) wrong end_query (%d!=%d)\n", functions[function_index].name, a, b, open, extend, matrixname, reference_result->end_query, result->end_query); if (exit_on_mismatch) exit(EXIT_FAILURE); } } if (reference_result->end_ref != result->end_ref) { #pragma omp critical(printer) { printf("%s(%lu,%lu,%d,%d,%s) wrong end_ref (%d!=%d)\n", functions[function_index].name, a, b, open, extend, matrixname, reference_result->end_ref, result->end_ref); if (exit_on_mismatch) exit(EXIT_FAILURE); } } if (diff_array(size_a, size_b, ref_score_table, score_table)) { #pragma omp critical(printer) { printf("%s(%lu,%lu,%d,%d,%s) bad score table\n", functions[function_index].name, a, b, open, extend, matrixname); if (exit_on_mismatch) exit(EXIT_FAILURE); } } if (parasail_result_is_stats(result)) { int ref_matches = parasail_result_get_matches(reference_result); int ref_similar = parasail_result_get_similar(reference_result); int ref_length = parasail_result_get_length(reference_result); int matches = parasail_result_get_matches(result); int similar = parasail_result_get_similar(result); int length = parasail_result_get_length(result); int *ref_matches_table = parasail_result_get_matches_table(reference_result); int *ref_similar_table = parasail_result_get_similar_table(reference_result); int *ref_length_table = parasail_result_get_length_table(reference_result); int *matches_table = parasail_result_get_matches_table(result); int *similar_table = parasail_result_get_similar_table(result); int *length_table = parasail_result_get_length_table(result); if (diff_array(size_a, size_b, ref_matches_table, matches_table)) { #pragma omp critical(printer) { printf("%s(%lu,%lu,%d,%d,%s) bad matches table\n", functions[function_index].name, a, b, open, extend, matrixname); if (exit_on_mismatch) exit(EXIT_FAILURE); } } if (ref_matches != matches) { #pragma omp critical(printer) { printf("%s(%lu,%lu,%d,%d,%s) wrong matches (%d!=%d)\n", functions[function_index].name, a, b, open, extend, matrixname, ref_matches, matches); if (exit_on_mismatch) exit(EXIT_FAILURE); } } if (diff_array(size_a, size_b, ref_similar_table, similar_table)) { #pragma omp critical(printer) { printf("%s(%lu,%lu,%d,%d,%s) bad similar table\n", functions[function_index].name, a, b, open, extend, matrixname); if (exit_on_mismatch) exit(EXIT_FAILURE); } } if (ref_similar != similar) { #pragma omp critical(printer) { printf("%s(%lu,%lu,%d,%d,%s) wrong similar (%d!=%d)\n", functions[function_index].name, a, b, open, extend, matrixname, ref_similar, similar); if (exit_on_mismatch) exit(EXIT_FAILURE); } } if (diff_array(size_a, size_b, ref_length_table, length_table)) { #pragma omp critical(printer) { printf("%s(%lu,%lu,%d,%d,%s) bad length table\n", functions[function_index].name, a, b, open, extend, matrixname); if (exit_on_mismatch) exit(EXIT_FAILURE); } } if (ref_length != length) { #pragma omp critical(printer) { printf("%s(%lu,%lu,%d,%d,%s) wrong length (%d!=%d)\n", functions[function_index].name, a, b, open, extend, matrixname, ref_length, length); if (exit_on_mismatch) exit(EXIT_FAILURE); } } } parasail_result_free(reference_result); parasail_result_free(result); } if (verbose && saturated) { printf("%s %d %d %s saturated %lu times\n", functions[function_index].name, open, extend, matrixname, saturated); } } if (gap.open != INT_MIN && gap.extend != INT_MIN) { /* user-specified gap, don't loop */ break; } } } }
pushq %rbp pushq %r15 pushq %r14 pushq %r13 pushq %r12 pushq %rbx subq $0x108, %rsp # imm = 0x108 movq %r9, 0x40(%rsp) movq %rcx, 0x58(%rsp) movq %rdx, 0x68(%rsp) movq %rsi, %rbx movq %rdi, %rsi leaq 0xf0(%rsp), %rax movq %r8, (%rax) movq $0x0, 0x8(%rax) testq %r8, %r8 leaq 0x5162b0(%rip), %r14 # 0x6bc320 cmovneq %rax, %r14 leaq 0x3d9b10(%rip), %rdi # 0x57fb8b xorl %eax, %eax callq 0x149040 movq %r14, 0x78(%rsp) movq (%r14), %rdx testq %rdx, %rdx je 0x1a68cf movq 0x40(%rsp), %rax movq %rax, %rcx shrq $0x20, %rcx negl %eax setno %al movq %rcx, 0x90(%rsp) cmpl $0x80000000, %ecx # imm = 0x80000000 setne %cl andb %al, %cl movb %cl, 0xf(%rsp) leaq 0x48(%rbx), %rax movq %rax, 0x88(%rsp) movb 0x539067(%rip), %al # 0x6df134 movl %eax, %ecx xorl %esi, %esi movq %rbx, 0xd8(%rsp) movq %rdx, 0x70(%rsp) movq (%rdx), %r14 testb $0x1, %cl movq %rsi, 0x80(%rsp) je 0x1a6109 leaq 0x3d9ac4(%rip), %rdi # 0x57fbb9 movq %r14, %rsi xorl %eax, %eax callq 0x149040 movb 0x53902f(%rip), %al # 0x6df134 movl %eax, %ecx jmp 0x1a610b xorl %ecx, %ecx movl 0x518fff(%rip), %esi # 0x6bf110 movl %esi, %edx negl %edx jo 0x1a68b1 movl %eax, %ecx movl %eax, %edx leaq 0x518fea(%rip), %rdi # 0x6bf110 xorl %r15d, %r15d movq %r14, 0x10(%rsp) movq 0x90(%rsp), %r8 movl %r8d, 0x4(%rsp) movq 0x40(%rsp), %r8 movl %r8d, 0x8(%rsp) cmpb $0x0, 0xf(%rsp) jne 0x1a6157 movl 0x4(%rdi), %edi movl %edi, 0x4(%rsp) movl %esi, 0x8(%rsp) testb $0x1, %dl je 0x1a617e leaq 0x3d9a3f(%rip), %rdi # 0x57fba2 movl 0x8(%rsp), %esi movl 0x4(%rsp), %edx xorl %eax, %eax callq 0x149040 movb 0x538fbc(%rip), %al # 0x6df134 movl %eax, %ecx movl %eax, %edx jmp 0x1a6180 xorl %edx, %edx cmpq $0x0, 0x48(%rbx) je 0x1a688a movq (%rbx), %rax movq %rax, 0xe0(%rsp) movl $0x1, %r14d movl %ecx, %eax movq 0x88(%rsp), %r12 movq %r15, 0x98(%rsp) testb $0x1, %al je 0x1a61c5 movq 0x8(%r12), %rsi leaq 0x3d99f9(%rip), %rdi # 0x57fbb7 xorl %eax, %eax callq 0x149040 movq %r14, 0x48(%rsp) cmpq $0x0, 0x58(%rsp) jle 0x1a685d xorl %eax, %eax xorl %r9d, %r9d movq %r12, 0x38(%rsp) cvtsi2sd %rax, %xmm0 movsd %xmm0, 0x20(%rsp) addsd %xmm0, %xmm0 ucomisd 0x3d9889(%rip), %xmm0 # 0x57fa80 movq %r9, 0x60(%rsp) movq %rax, 0xe8(%rsp) jb 0x1a620c sqrtsd %xmm0, %xmm0 jmp 0x1a6211 callq 0x1490f0 callq 0x1491e0 movsd 0x3d9842(%rip), %xmm2 # 0x57fa60 addsd %xmm2, %xmm0 movsd 0x3d983e(%rip), %xmm3 # 0x57fa68 movapd %xmm3, %xmm1 maxsd %xmm0, %xmm1 movapd %xmm1, %xmm0 addsd %xmm2, %xmm0 mulsd %xmm1, %xmm0 mulsd 0x3d982a(%rip), %xmm0 # 0x57fa70 movsd 0x20(%rsp), %xmm4 movapd %xmm4, %xmm2 subsd %xmm0, %xmm2 ucomisd %xmm1, %xmm2 jb 0x1a6264 addsd %xmm1, %xmm0 addsd %xmm3, %xmm1 jmp 0x1a624c cvttsd2si %xmm2, %rax movsd 0x3d9807(%rip), %xmm0 # 0x57fa78 subsd %xmm0, %xmm2 cvttsd2si %xmm2, %rcx movq %rax, %rbx sarq $0x3f, %rbx andq %rcx, %rbx orq %rax, %rbx cvttsd2si %xmm1, %rax subsd %xmm0, %xmm1 cvttsd2si %xmm1, %rcx movq %rax, %r12 sarq $0x3f, %r12 andq %rcx, %r12 orq %rax, %r12 movq 0x68(%rsp), %rax movq (%rax), %rax movq %rbx, %r14 shlq $0x6, %r14 movq 0x20(%rax,%r14), %rsi movq %rsi, 0x30(%rsp) movq 0x28(%rax,%r14), %rdi movq %r12, %r15 shlq $0x6, %r15 movq 0x20(%rax,%r15), %r13 movq 0x28(%rax,%r15), %rdx subq $0x8, %rsp movl %r13d, %ecx movl 0x10(%rsp), %ebp movl %ebp, %r8d movl 0xc(%rsp), %r9d pushq 0x78(%rsp) callq *0xf0(%rsp) addq $0x10, %rsp movq %rax, 0x20(%rsp) movq 0x68(%rsp), %rax movq (%rax), %rax movq 0x28(%rax,%r14), %rdi movq 0x28(%rax,%r15), %rdx movq 0x30(%rsp), %rsi subq $0x8, %rsp movq %r13, 0x20(%rsp) movl %r13d, %ecx movl %ebp, %r8d movl 0xc(%rsp), %r9d pushq 0x78(%rsp) movq 0x48(%rsp), %rbp callq *(%rbp) addq $0x10, %rsp movq %rax, %r14 movq %rax, %rdi callq 0x1a8332 testl %eax, %eax je 0x1a6361 movq 0x20(%rsp), %rdi callq 0x1a74c0 movq %r14, %rdi callq 0x1a74c0 movq 0x60(%rsp), %r9 incq %r9 jmp 0x1a6800 movq 0x20(%rsp), %r13 movq %r13, %rdi callq 0x1a8533 movq %rax, %rbp movq %r14, %rdi callq 0x1a8533 movq %rax, %r15 movl (%r13), %r10d movq %r14, 0x50(%rsp) movl (%r14), %r11d cmpl %r11d, %r10d movq 0x10(%rsp), %r14 movq %rbx, %rdx movq %r12, %rbx movq %rdx, 0x28(%rsp) je 0x1a63e1 movq 0x38(%rsp), %rax movq 0x8(%rax), %rsi subq $0x8, %rsp leaq 0x3d980d(%rip), %rdi # 0x57fbbe movq %rbx, %rcx movl 0x10(%rsp), %r8d movl 0xc(%rsp), %r9d xorl %eax, %eax pushq %r11 pushq %r10 pushq %r14 callq 0x149040 movq 0x48(%rsp), %rdx addq $0x20, %rsp cmpb $0x1, 0x538d5d(%rip) # 0x6df138 je 0x1a68e1 movq 0x20(%rsp), %r12 movl 0x4(%r12), %r10d movq 0x50(%rsp), %r14 movl 0x4(%r14), %r11d cmpl %r11d, %r10d movq 0x38(%rsp), %r13 je 0x1a643f movq 0x8(%r13), %rsi subq $0x8, %rsp leaq 0x3d97dc(%rip), %rdi # 0x57fbe9 movq %rbx, %rcx movl 0x10(%rsp), %r8d movl 0xc(%rsp), %r9d xorl %eax, %eax pushq %r11 pushq %r10 pushq 0x28(%rsp) callq 0x149040 movq 0x48(%rsp), %rdx addq $0x20, %rsp cmpb $0x1, 0x538cff(%rip) # 0x6df138 je 0x1a68e1 movl 0x8(%r12), %r10d movl 0x8(%r14), %r11d cmpl %r11d, %r10d je 0x1a648e movq 0x8(%r13), %rsi subq $0x8, %rsp leaq 0x3d97bc(%rip), %rdi # 0x57fc18 movq %rbx, %rcx movl 0x10(%rsp), %r8d movl 0xc(%rsp), %r9d xorl %eax, %eax pushq %r11 pushq %r10 pushq 0x28(%rsp) callq 0x149040 movq 0x48(%rsp), %rdx addq $0x20, %rsp cmpb $0x1, 0x538cb0(%rip) # 0x6df138 je 0x1a68e1 movq 0x18(%rsp), %rsi imulq 0x30(%rsp), %rsi testq %rsi, %rsi movq %rsi, 0x18(%rsp) je 0x1a64f1 xorl %eax, %eax movl (%rbp,%rax,4), %ecx cmpl (%r15,%rax,4), %ecx jne 0x1a64b9 incq %rax cmpq %rax, %rsi jne 0x1a64a5 jmp 0x1a64f1 movq 0x8(%r13), %rsi subq $0x8, %rsp leaq 0x3d977d(%rip), %rdi # 0x57fc45 movq %rbx, %rcx movl 0x10(%rsp), %r8d movl 0xc(%rsp), %r9d xorl %eax, %eax pushq 0x18(%rsp) callq 0x149040 addq $0x10, %rsp cmpb $0x1, 0x538c4d(%rip) # 0x6df138 je 0x1a68e1 movq %r14, %rdi callq 0x1a83d2 testl %eax, %eax movq %r14, %r12 movq %r13, %rbp je 0x1a67e9 movq %rbx, 0x30(%rsp) movq 0x20(%rsp), %r14 movq %r14, %rdi callq 0x1a84c5 movq %rax, 0xd0(%rsp) movq %r14, %rdi callq 0x1a84e9 movq %rax, 0xc0(%rsp) movq %r14, %rdi callq 0x1a850e movq %rax, 0xb0(%rsp) movq %r12, %rdi callq 0x1a84c5 movq %rax, 0xc8(%rsp) movq %r12, %rdi callq 0x1a84e9 movq %rax, 0xb8(%rsp) movq %r12, %rdi callq 0x1a850e movq %rax, 0xa8(%rsp) movq %r14, %rdi callq 0x1a856d movq %rax, %rbx movq %r14, %rdi callq 0x1a859d movq %rax, %r15 movq %r14, %rdi callq 0x1a85cd movq %rax, 0xa0(%rsp) movq %r12, %rdi callq 0x1a856d movq %rax, %r14 movq %r12, %rdi callq 0x1a859d movq %rax, %r13 movq %r12, %rdi callq 0x1a85cd movq %rax, %r12 movq 0x18(%rsp), %rdx testq %rdx, %rdx je 0x1a661b xorl %eax, %eax movl (%rbx,%rax,4), %ecx cmpl (%r14,%rax,4), %ecx jne 0x1a65d7 incq %rax cmpq %rax, %rdx jne 0x1a65c4 jmp 0x1a661b movq 0x8(%rbp), %rsi subq $0x8, %rsp leaq 0x3d9685(%rip), %rdi # 0x57fc6b movq 0x30(%rsp), %rdx movq 0x38(%rsp), %rcx movl 0x10(%rsp), %r8d movl 0xc(%rsp), %r9d xorl %eax, %eax pushq 0x18(%rsp) callq 0x149040 movq 0x28(%rsp), %rdx addq $0x10, %rsp cmpb $0x1, 0x538b23(%rip) # 0x6df138 je 0x1a68e1 movq 0xd0(%rsp), %r10 movq 0xc8(%rsp), %r11 cmpl %r11d, %r10d movq 0x28(%rsp), %rbx movq 0x30(%rsp), %r14 je 0x1a667e movq 0x8(%rbp), %rsi subq $0x8, %rsp leaq 0x3d964a(%rip), %rdi # 0x57fc93 movq %rbx, %rdx movq %r14, %rcx movl 0x10(%rsp), %r8d movl 0xc(%rsp), %r9d xorl %eax, %eax pushq %r11 pushq %r10 pushq 0x28(%rsp) callq 0x149040 movq 0x38(%rsp), %rdx addq $0x20, %rsp cmpb $0x1, 0x538ac0(%rip) # 0x6df138 je 0x1a68e1 testq %rdx, %rdx je 0x1a66da xorl %eax, %eax movl (%r15,%rax,4), %ecx cmpl (%r13,%rax,4), %ecx jne 0x1a669a incq %rax cmpq %rax, %rdx jne 0x1a6685 jmp 0x1a66da movq 0x8(%rbp), %rsi subq $0x8, %rsp leaq 0x3d9617(%rip), %rdi # 0x57fcc0 movq %rbx, %rdx movq %r14, %rcx movl 0x10(%rsp), %r8d movl 0xc(%rsp), %r9d xorl %eax, %eax pushq 0x18(%rsp) callq 0x149040 movq 0x28(%rsp), %rdx addq $0x10, %rsp cmpb $0x1, 0x538a64(%rip) # 0x6df138 je 0x1a68e1 movq 0xc0(%rsp), %r10 movq 0xb8(%rsp), %r11 cmpl %r11d, %r10d je 0x1a6733 movq 0x8(%rbp), %rsi subq $0x8, %rsp leaq 0x3d95ea(%rip), %rdi # 0x57fce8 movq %rbx, %rdx movq %r14, %rcx movl 0x10(%rsp), %r8d movl 0xc(%rsp), %r9d xorl %eax, %eax pushq %r11 pushq %r10 pushq 0x28(%rsp) callq 0x149040 movq 0x38(%rsp), %rdx addq $0x20, %rsp cmpb $0x1, 0x538a0b(%rip) # 0x6df138 je 0x1a68e1 testq %rdx, %rdx movq 0xb0(%rsp), %r15 movq 0xa8(%rsp), %r13 movq 0xa0(%rsp), %rsi je 0x1a67a0 xorl %eax, %eax movl (%rsi,%rax,4), %ecx cmpl (%r12,%rax,4), %ecx jne 0x1a6765 incq %rax cmpq %rax, %rdx jne 0x1a6752 jmp 0x1a67a0 movq 0x8(%rbp), %rsi subq $0x8, %rsp leaq 0x3d95a1(%rip), %rdi # 0x57fd15 movq %rbx, %rdx movq %r14, %rcx movl 0x10(%rsp), %r8d movl 0xc(%rsp), %r9d xorl %eax, %eax pushq 0x18(%rsp) callq 0x149040 addq $0x10, %rsp cmpb $0x1, 0x53899e(%rip) # 0x6df138 je 0x1a68e1 cmpl %r13d, %r15d movq 0x50(%rsp), %r12 je 0x1a67e9 movq 0x8(%rbp), %rsi subq $0x8, %rsp leaq 0x3d9583(%rip), %rdi # 0x57fd3c movq %rbx, %rdx movq %r14, %rcx movl 0x10(%rsp), %r8d movl 0xc(%rsp), %r9d xorl %eax, %eax pushq %r13 pushq %r15 pushq 0x28(%rsp) callq 0x149040 addq $0x20, %rsp cmpb $0x1, 0x538955(%rip) # 0x6df138 je 0x1a68e1 movq 0x20(%rsp), %rdi callq 0x1a74c0 movq %r12, %rdi callq 0x1a74c0 movq 0x60(%rsp), %r9 movq 0x10(%rsp), %r8 movq 0xe8(%rsp), %rax incq %rax cmpq 0x58(%rsp), %rax movq 0xd8(%rsp), %rbx jne 0x1a61e0 movb 0x53890b(%rip), %al # 0x6df134 testq %r9, %r9 setne %cl andb %al, %cl cmpb $0x1, %cl movq 0x48(%rsp), %r14 jne 0x1a6868 movq 0x8(%rbp), %rsi leaq 0x3d9522(%rip), %rdi # 0x57fd68 movl 0x8(%rsp), %edx movl 0x4(%rsp), %ecx xorl %eax, %eax callq 0x149040 movb 0x5388d9(%rip), %al # 0x6df134 jmp 0x1a6868 movb 0x5388d1(%rip), %al # 0x6df134 movq 0x48(%rsp), %r14 incq %r14 leaq (%r14,%r14,8), %rcx leaq (%rbx,%rcx,8), %r12 cmpq $0x0, (%r12) movl %eax, %ecx movl %eax, %edx movq 0x98(%rsp), %r15 jne 0x1a61ae cmpb $0x0, 0xf(%rsp) jne 0x1a68b1 leaq 0x518878(%rip), %rsi # 0x6bf110 leaq (%rsi,%r15,8), %rdi addq $0x8, %rdi incq %r15 movl (%rdi), %esi movl %esi, %r8d negl %r8d jno 0x1a612e movq 0x78(%rsp), %rdx movq 0x80(%rsp), %rsi movq 0x8(%rdx,%rsi,8), %rdx incq %rsi testq %rdx, %rdx jne 0x1a60d9 addq $0x108, %rsp # imm = 0x108 popq %rbx popq %r12 popq %r13 popq %r14 popq %r15 popq %rbp retq movl $0x1, %edi callq 0x149170 nop
/workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/tests/test_verify_tables.c