LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/sqlite3.c
// Function: sqlite3NotPureFunc
SQLITE_PRIVATE int sqlite3NotPureFunc(sqlite3_context *pCtx){
#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
  if( pCtx->pVdbe==0 ) return 1;
#endif
  if( pCtx->pVdbe->aOp[pCtx->iOp].opcode==OP_PureFunc ){
    sqlite3_result_error(pCtx, 
       "non-deterministic function in index expression or CHECK constraint",
       -1);
    return 0;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x68(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x20(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movzbl (%rax), %eax
cmpl $0x40, %eax
jne 0x4a7d1d
movq -0x10(%rbp), %rdi
leaq 0xda985(%rip), %rsi     # 0x58268f
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x40daa0
movl $0x0, -0x4(%rbp)
jmp 0x4a7d24
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/sqlite3.c
// Function: pcache1PinPage
static PgHdr1 *pcache1PinPage(PgHdr1 *pPage){
  assert( pPage!=0 );
  assert( PAGE_IS_UNPINNED(pPage) );
  assert( pPage->pLruNext );
  assert( pPage->pLruPrev );
  assert( sqlite3_mutex_held(pPage->pCache->pGroup->mutex) );
  pPage->pLruPrev->pLruNext = pPage->pLruNext;
  pPage->pLruNext->pLruPrev = pPage->pLruPrev;
  pPage->pLruNext = 0;
  pPage->pLruPrev = 0;
  assert( pPage->isAnchor==0 );
  assert( pPage->pCache->pGroup->lru.isAnchor==1 );
  pPage->pCache->nRecyclable--;
  return pPage;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x30(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/util.c
// Function: trim_space
char* trim_space(const char* s) {
  size_t start = 0;
  while (start < strlen(s) && isspace(s[start])) {
    start++;
  }
  size_t limit = strlen(s);
  while (limit > start && isspace(s[limit - 1])) {
    limit--;
  }

  char* res = calloc(sizeof(char), limit - start + 1);
  for (size_t i = 0; i < limit - start; i++)
    res[i] = s[start + i];
  res[limit - start] = '\0';

  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4010f8
movq -0x38(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x29(%rbp)
jae 0x4aa04f
callq 0x4ace80
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x4aa058
jmp 0x4aa066
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4aa004
movq -0x8(%rbp), %rdi
callq 0x4010f8
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x39(%rbp)
jbe 0x4aa0af
callq 0x4ace80
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x4aa0b8
jmp 0x4aa0c6
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4aa073
movq -0x18(%rbp), %rsi
subq -0x10(%rbp), %rsi
addq $0x1, %rsi
movl $0x1, %edi
callq 0x4d5ca0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jae 0x4aa121
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
addq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4aa0e8
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/veltzer[P]xmeltdown/src/grid.c
// Function: Initialize
void Initialize(int argc, char** argv)
{
	XSizeHints size_hints;
	if (!(dpy=XOpenDisplay(""))) {
		printf ("Error: Can't open display.");
		exit(-1);
	}
	screen=DefaultScreen(dpy);

	size_hints.width=400;
	size_hints.height=400;
	size_hints.flags=PSize;

	win=XCreateSimpleWindow(dpy,
		DefaultRootWindow(dpy),
		0, 0,
		size_hints.width,
		size_hints.height,
		4,
		BlackPixel(dpy, screen),
		WhitePixel(dpy, screen));

	XSetStandardProperties (dpy, win, "GC demo",
		"stickman",
		None, argv, argc, &size_hints);

	XMapWindow(dpy, win);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xe25(%rip), %rdi       # 0x201e
callq 0x1060
movq %rax, 0x2e8b(%rip)      # 0x4090
cmpq $0x0, %rax
jne 0x1223
leaq 0xdf2(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1040
movq 0x2e66(%rip), %rax      # 0x4090
movl 0xe0(%rax), %eax
movl %eax, 0x2e62(%rip)      # 0x4098
movl $0x190, -0x50(%rbp)     # imm = 0x190
movl $0x190, -0x4c(%rbp)     # imm = 0x190
movq $0x8, -0x60(%rbp)
movq 0x2e3d(%rip), %rdi      # 0x4090
movq 0x2e36(%rip), %rax      # 0x4090
movq 0xe8(%rax), %rax
movq 0x2e28(%rip), %rcx      # 0x4090
movslq 0xe0(%rcx), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
movl -0x50(%rbp), %r8d
movl -0x4c(%rbp), %r9d
movq 0x2e07(%rip), %rax      # 0x4090
movq 0xe8(%rax), %rax
movslq 0x2e01(%rip), %rcx      # 0x4098
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x60(%rax), %r10
movq 0x2de7(%rip), %rax      # 0x4090
movq 0xe8(%rax), %rax
movslq 0x2de1(%rip), %rcx      # 0x4098
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x58(%rax), %rax
xorl %ecx, %ecx
movl %ecx, %edx
movl $0x4, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x1050
movq %rax, 0x2dbd(%rip)      # 0x40a0
movq 0x2da6(%rip), %rdi      # 0x4090
movq 0x2daf(%rip), %rsi      # 0x40a0
movq -0x10(%rbp), %r9
movl -0x4(%rbp), %r10d
leaq 0xd1f(%rip), %rdx       # 0x201f
leaq 0xd20(%rip), %rcx       # 0x2027
xorl %eax, %eax
movl %eax, %r8d
leaq -0x60(%rbp), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x10d0
movq 0x2d6b(%rip), %rdi      # 0x4090
movq 0x2d74(%rip), %rsi      # 0x40a0
callq 0x10a0
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/veltzer[P]xmeltdown/src/grid.c
// Function: DrawGrid
void DrawGrid(void) {
	int fromx, fromy, tox, toy;
	int counter;
	for (counter=0; counter < 16; counter++) {
		fromx=counter*10;
		fromy=0;
		tox=counter*10;
		toy=400;
		XDrawLine(dpy, win,
			gc_list[counter],
			fromx, fromy, tox, toy);

		fromx=0;
		fromy=counter*10;
		tox=400;
		toy=counter*10;
		XDrawLine(dpy, win,
			gc_list[counter],
			fromx, fromy, tox, toy);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x1405
imull $0xa, -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
imull $0xa, -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movl $0x190, -0x10(%rbp)     # imm = 0x190
movq 0x2d14(%rip), %rdi      # 0x4090
movq 0x2d1d(%rip), %rsi      # 0x40a0
movslq -0x14(%rbp), %rcx
leaq 0x2d22(%rip), %rax      # 0x40b0
movq (%rax,%rcx,8), %rdx
movl -0x4(%rbp), %ecx
movl -0x8(%rbp), %r8d
movl -0xc(%rbp), %r9d
movl -0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x1070
movl $0x0, -0x4(%rbp)
imull $0xa, -0x14(%rbp), %eax
movl %eax, -0x8(%rbp)
movl $0x190, -0xc(%rbp)      # imm = 0x190
imull $0xa, -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movq 0x2cc5(%rip), %rdi      # 0x4090
movq 0x2cce(%rip), %rsi      # 0x40a0
movslq -0x14(%rbp), %rcx
leaq 0x2cd3(%rip), %rax      # 0x40b0
movq (%rax,%rcx,8), %rdx
movl -0x4(%rbp), %ecx
movl -0x8(%rbp), %r8d
movl -0xc(%rbp), %r9d
movl -0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x1070
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x134f
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/veltzer[P]xmeltdown/src/grid.c
// Function: main
int main(int argc, char** argv) {
	XGCValues my_gcvalues;
	XEvent my_event;
	int counter;

	Initialize(argc, argv);

	XSelectInput(dpy, win,
		ExposureMask|ButtonPressMask|ButtonReleaseMask|
		ButtonMotionMask|KeyPressMask);

	my_gcvalues.line_width=5;
	my_gcvalues.line_style=LineSolid;
	for (counter=0; counter < 16; counter++) {
		my_gcvalues.function=counter;

		gc_list[counter]=XCreateGC(dpy, win,
			GCFunction|GCLineWidth|GCLineStyle,
			&my_gcvalues);
	}
	while (1) {
		XNextEvent (dpy, &my_event);
		if (my_event.type == Expose)
			DrawGrid();
		if (my_event.type == ButtonPress)
			DrawGrid();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x11e0
movq 0x2c14(%rip), %rdi      # 0x4090
movq 0x2c1d(%rip), %rsi      # 0x40a0
movl $0xa00d, %edx           # imm = 0xA00D
callq 0x10c0
movl $0x5, -0x70(%rbp)
movl $0x0, -0x6c(%rbp)
movl $0x0, -0x154(%rbp)
cmpl $0x10, -0x154(%rbp)
jge 0x14ff
movl -0x154(%rbp), %eax
movl %eax, -0x90(%rbp)
movq 0x2bcf(%rip), %rdi      # 0x4090
movq 0x2bd8(%rip), %rsi      # 0x40a0
movl $0x31, %edx
leaq -0x90(%rbp), %rcx
callq 0x10b0
movq %rax, %rdx
movslq -0x154(%rbp), %rcx
leaq 0x2bc6(%rip), %rax      # 0x40b0
movq %rdx, (%rax,%rcx,8)
movl -0x154(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x154(%rbp)
jmp 0x14a5
jmp 0x1501
movq 0x2b88(%rip), %rdi      # 0x4090
leaq -0x150(%rbp), %rsi
callq 0x1090
cmpl $0xc, -0x150(%rbp)
jne 0x1522
callq 0x1340
cmpl $0x4, -0x150(%rbp)
jne 0x1530
callq 0x1340
jmp 0x1501
// File: /workspace/github_c_makefile_star2_O0/fabiovila[P]fs2ch/fs2ch.cpp
// Function: listfolder(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void listfolder(const std::string& path)
{
	
    if (!path.empty())
    {
        namespace fs = boost::filesystem;

        fs::path apk_path(path);
        fs::recursive_directory_iterator end;

        for (fs::recursive_directory_iterator i(apk_path); i != end; ++i)
        {
            const fs::path cp = (*i);
            List.push_back(cp.string());
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3400
testb $0x1, %al
jne 0xa001
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xf410
leaq -0x30(%rbp), %rdi
callq 0xf440
movq -0x70(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xf460
jmp 0x9f09
jmp 0x9f0b
leaq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xf4c0
movb %al, -0x71(%rbp)
jmp 0x9f1d
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x9f53
jmp 0x9f26
leaq -0x38(%rbp), %rdi
callq 0xf640
jmp 0x9fd9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x9fed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x9fce
leaq -0x38(%rbp), %rdi
callq 0xf500
movq %rax, -0x80(%rbp)
jmp 0x9f62
movq -0x80(%rbp), %rdi
callq 0xf530
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0xf540
jmp 0x9f79
leaq -0x68(%rbp), %rdi
callq 0xf5e0
movq %rax, -0x88(%rbp)
jmp 0x9f8b
movq -0x88(%rbp), %rsi
leaq 0x1c2df(%rip), %rdi     # 0x26278
callq 0xf570
jmp 0x9fa0
leaq -0x68(%rbp), %rdi
callq 0xf5f0
leaq -0x38(%rbp), %rdi
callq 0xf610
jmp 0x9fb4
jmp 0x9f0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xf5f0
leaq -0x38(%rbp), %rdi
callq 0xf640
jmp 0x9fed
leaq -0x30(%rbp), %rdi
callq 0xf640
leaq -0x28(%rbp), %rdi
callq 0xf5f0
jmp 0xa001
leaq -0x30(%rbp), %rdi
callq 0xf640
leaq -0x28(%rbp), %rdi
callq 0xf5f0
jmp 0xa00a
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kyz[P]amostools/unlockamos.c
// Function: main
int main(int argc, char *argv[]) {
    char *fname;
    uint8_t *buf;
    size_t len;

    if (argc <= 1) {
        printf("Unlock \"locked\" procedures in AMOS source code.\n");
        printf("Usage: %s <file(s).amos>\n", argv[0]);
        return 1;
    }

    for (argv++; (fname = *argv); argv++) {
        if ((buf = read_file(fname, &len))) {
            if (!memcmp(buf, "AMOS Basic", 10)) {
                if (unlock_source(buf, len)) {
                    printf("%s: unlocked procedures, saving\n", fname);
                    write_file(fname, buf, len);
                }
                else {
                    printf("%s: no locked procedures\n", fname);
                }
            }
            else {
                printf("%s: not an AMOS Basic file\n", fname);
            }
            free(buf);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jg 0x172b
leaq 0x94b(%rip), %rdi       # 0x204e
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x967(%rip), %rdi       # 0x207f
movb $0x0, %al
callq 0x1070
movl $0x1, -0x4(%rbp)
jmp 0x1801
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x17fa
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x11e0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x17e7
movq -0x20(%rbp), %rdi
leaq 0x927(%rip), %rsi       # 0x2099
movl $0xa, %edx
callq 0x1080
cmpl $0x0, %eax
jne 0x17cc
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1550
cmpl $0x0, %eax
je 0x17b8
movq -0x18(%rbp), %rsi
leaq 0x906(%rip), %rdi       # 0x20a4
movb $0x0, %al
callq 0x1070
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1310
jmp 0x17ca
movq -0x18(%rbp), %rsi
leaq 0x902(%rip), %rdi       # 0x20c5
movb $0x0, %al
callq 0x1070
jmp 0x17de
movq -0x18(%rbp), %rsi
leaq 0x908(%rip), %rdi       # 0x20df
movb $0x0, %al
callq 0x1070
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x17e9
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x1737
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/filter/fir.c
// Function: readCoefficients
static void
readCoefficients(char *fileName)
    {
    FILE *fp;
    double coeff;

    fprintf(stderr,"reading coefficients: %s\n",fileName);

    fp = OpenFile(fileName,"r");

    totalWeight = 0;
    numberOfTaps = 0;
    while (fscanf(fp," %lf",&coeff) != -1)
        {
        if (numberOfTaps >= MAX_TAPS)
            Fatal("fir: too many coefficients!\n");
        coefficients[numberOfTaps] = coeff;
        totalWeight += coeff;
        ++numberOfTaps;
        }

    fprintf(stderr,"total coefficient weight: %f\n",totalWeight);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x67a5(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x38a3(%rip), %rsi      # 0x5104
movb $0x0, %al
callq 0x1120
movq -0x8(%rbp), %rdi
leaq 0x3d95(%rip), %rsi      # 0x5608
callq 0x1b30
movq %rax, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x88e9(%rip)     # 0xa170
movl $0x0, 0x68cf(%rip)      # 0x8160
movq -0x10(%rbp), %rdi
leaq 0x3882(%rip), %rsi      # 0x511e
leaq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0x1050
cmpl $-0x1, %eax
je 0x1904
cmpl $0x400, 0x68aa(%rip)    # imm = 0x400
jl 0x18c6
leaq 0x3864(%rip), %rdi      # 0x5123
movb $0x0, %al
callq 0x19e0
movsd -0x18(%rbp), %xmm0
movslq 0x688e(%rip), %rcx      # 0x8160
leaq 0x6897(%rip), %rax      # 0x8170
movsd %xmm0, (%rax,%rcx,8)
movsd -0x18(%rbp), %xmm0
addsd 0x8885(%rip), %xmm0     # 0xa170
movsd %xmm0, 0x887d(%rip)     # 0xa170
movl 0x6867(%rip), %eax      # 0x8160
addl $0x1, %eax
movl %eax, 0x685e(%rip)      # 0x8160
jmp 0x1891
movq 0x66ed(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movsd 0x885a(%rip), %xmm0     # 0xa170
leaq 0x3823(%rip), %rsi      # 0x5140
movb $0x1, %al
callq 0x1120
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/filter/fir.c
// Function: firFilter
static double
firFilter(double value,double *buffer,double *coeffs,int length,int *index)
    {
    int i;
    double total;

    buffer[*index] = value;

    total = 0; 
    for (i = 0; i < length; i++) 
        { 
        total += coeffs[i] * buffer[(*index + i) % length]; 
        } 
    *index = (*index + 1) % length; 

    return total;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq (%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x19bf
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
addl -0x2c(%rbp), %eax
cltd
idivl -0x1c(%rbp)
movq -0x40(%rbp), %rax
movslq %edx, %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x196c
movq -0x28(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
cltd
idivl -0x1c(%rbp)
movq -0x28(%rbp), %rax
movl %edx, (%rax)
movsd -0x38(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mulle-nat[P]long-long-double-trouble/long.c
// Function: fits_long
int   fits_long( double value)
{
   long   l_val;
   int    fits;

   if( value < (double) LONG_MIN || value > (double) LONG_MAX)
      return( 0);

   l_val = (long) value;
   fits  = (double) l_val == value;
   if( ! fits)
      fprintf( stderr, "Mismatch %f with %ld\n", value, l_val);

   return( fits);
}

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x18(%rsp)
movsd 0xe96(%rip), %xmm0      # 0x2008
ucomisd 0x18(%rsp), %xmm0
ja 0x118e
movsd 0x18(%rsp), %xmm0
movsd 0xe88(%rip), %xmm1      # 0x2010
ucomisd %xmm1, %xmm0
jbe 0x1198
movl $0x0, 0x24(%rsp)
jmp 0x11f4
cvttsd2si 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cvtsi2sdq 0x10(%rsp), %xmm0
ucomisd 0x18(%rsp), %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x11ec
movq 0x2e28(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movsd 0x18(%rsp), %xmm0
movq 0x10(%rsp), %rdx
leaq 0xe43(%rip), %rsi       # 0x2028
movb $0x1, %al
callq 0x1040
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mulle-nat[P]long-long-double-trouble/long.c
// Function: main
int   main( int argc, char *argv[])
{
   double  value;

   fprintf( stderr, "long (%d bytes): %ld - %ld\n", (int) sizeof( long), LONG_MIN, LONG_MAX);
   fprintf( stderr, "double (%d bytes): %g - %g\n", (int) sizeof( double), DBL_MIN, DBL_MAX);

   assert( (double) LONG_MAX <= DBL_MAX);

   // keep my code optimiza
   if( argc == 1)
      value = (double) LONG_MAX;
   else
      value = (double) (LONG_MAX - atoi( argv[ 1]));

   if( fits_long( value))
      printf( "FITS\n");
   else
      printf( "NOPE\n");
   return( 0);
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x2ddc(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe18(%rip), %rsi       # 0x203e
movl $0x8, %edx
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
movb $0x0, %al
callq 0x1040
movq 0x2dab(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe03(%rip), %rsi       # 0x205a
movl $0x8, %edx
movsd 0xdb4(%rip), %xmm0      # 0x2018
movsd 0xdb4(%rip), %xmm1      # 0x2020
movb $0x2, %al
callq 0x1040
cmpl $0x1, 0x10(%rsp)
jne 0x1289
movsd 0xd8e(%rip), %xmm0      # 0x2010
movsd %xmm0, (%rsp)
jmp 0x12b1
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1050
movslq %eax, %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
subq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
callq 0x1160
cmpl $0x0, %eax
je 0x12d0
leaq 0xdaf(%rip), %rdi       # 0x2076
movb $0x0, %al
callq 0x1030
jmp 0x12de
leaq 0xda5(%rip), %rdi       # 0x207c
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_array/queue.c
// Function: clear
void clear(Queue q)
{
    assert(q!=NULL);
    q->size=0;
    q->front=1;
    q->end=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1205
jmp 0x1224
leaq 0xdf8(%rip), %rdi       # 0x2004
leaq 0xdf9(%rip), %rsi       # 0x200c
movl $0x2c, %edx
leaq 0xdf5(%rip), %rcx       # 0x2014
callq 0x1050
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_array/queue.c
// Function: create
Queue create(int maxSize)
{
    Queue q;
    q=(Queue)malloc(sizeof(struct QueueRecord));
    if(q==NULL)
    {
        fatal("queue malloc failed.");
    }
    q->data=malloc(sizeof(int)*maxSize);
    q->capacity=maxSize;
    if(q->data==NULL)
    {
        fatal("data array malloc failed.");
    }
    clear(q);
    return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x18, %edi
callq 0x1060
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x127c
leaq 0xdaf(%rip), %rdi       # 0x2026
callq 0x1180
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1060
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x12b4
leaq 0xd8c(%rip), %rdi       # 0x203b
callq 0x1180
movq -0x10(%rbp), %rdi
callq 0x11f0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_array/queue.c
// Function: print
void print(Queue q)
{
    assert(q!=NULL);
    if(isEmpty(q))
    {
        printf("queue is empty.\n");
        return;
    }
    for(int i=q->front; i<(q->front+q->size); i++)
    {

        int cursor=i;
        if(cursor>=q->capacity)
        {
            cursor=i-q->capacity;
        }
        printf("%d ", q->data[cursor]);
    }

    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1335
jmp 0x1354
leaq 0xcc8(%rip), %rdi       # 0x2004
leaq 0xcc9(%rip), %rsi       # 0x200c
movl $0x4d, %edx
leaq 0xd1a(%rip), %rcx       # 0x2069
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x11b0
cmpl $0x0, %eax
je 0x1372
leaq 0xd12(%rip), %rdi       # 0x207b
movb $0x0, %al
callq 0x1040
jmp 0x13e4
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq -0x8(%rbp), %rdx
addl 0xc(%rdx), %ecx
cmpl %ecx, %eax
jge 0x13d6
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x13ae
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0xcc8(%rip), %rdi       # 0x208c
movb $0x0, %al
callq 0x1040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x137c
leaq 0xd3a(%rip), %rdi       # 0x2117
movb $0x0, %al
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_array/queue.c
// Function: enqueue
void enqueue(int value, Queue q)
{
    assert(q!=NULL);
    if(isFull(q))
    {
        fatal("queue is full.");
    }
    q->size++;
    if(++q->end==q->capacity)
    {
        q->end=0;
    }
    q->data[q->end]=value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1408
jmp 0x1427
leaq 0xbf5(%rip), %rdi       # 0x2004
leaq 0xbf6(%rip), %rsi       # 0x200c
movl $0x63, %edx
leaq 0xc6e(%rip), %rcx       # 0x2090
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x11d0
cmpl $0x0, %eax
je 0x1441
leaq 0xc6d(%rip), %rdi       # 0x20a9
callq 0x1180
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x8(%rcx)
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x146e
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_array/queue.c
// Function: dequeue
int dequeue(Queue q)
{
    assert(q!=NULL);
    if(isEmpty(q))
    {
        fatal("queue is empty.");
    }
    q->size--;
    int tmp= q->data[q->front];
    if(++q->front==q->capacity)
    {
        q->front=0;
    }
    return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x14a5
jmp 0x14c4
leaq 0xb58(%rip), %rdi       # 0x2004
leaq 0xb59(%rip), %rsi       # 0x200c
movl $0x72, %edx
leaq 0xbf9(%rip), %rcx       # 0x20b8
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x11b0
cmpl $0x0, %eax
je 0x14de
leaq 0xbf2(%rip), %rdi       # 0x20cb
callq 0x1180
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx)
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1521
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_array/queue.c
// Function: main
int main(int argc, char **argv)
{
    Queue q=create(10);
    for(int i=0; i<10; i++)
    {
        enqueue(i, q);
        print(q);
    }
    printInfo(q);
    printf("===========================\n");
    for(int i=0; i<8; i++)
    {
        dequeue(q);
        print(q);
    }
    printInfo(q);
    printf("===========================\n");
    for(int i=0; i<7; i++)
    {
        enqueue(-i,q);
        print(q);
    }
    printInfo(q);
    printf("===========================\n");
    for(int i=0; i<6; i++)
    {
        dequeue(q);
        print(q);
    }
    printInfo(q);
    printf("===========================\n");
    clear(q);
    print(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xa, %edi
callq 0x1250
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x15d1
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x13f0
movq -0x18(%rbp), %rdi
callq 0x1320
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15ab
movq -0x18(%rbp), %rdi
callq 0x16d0
leaq 0xb0b(%rip), %rdi       # 0x20ec
movb $0x0, %al
callq 0x1040
movl $0x0, -0x20(%rbp)
cmpl $0x8, -0x20(%rbp)
jge 0x1612
movq -0x18(%rbp), %rdi
callq 0x1490
movq -0x18(%rbp), %rdi
callq 0x1320
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x15ef
movq -0x18(%rbp), %rdi
callq 0x16d0
leaq 0xaca(%rip), %rdi       # 0x20ec
movb $0x0, %al
callq 0x1040
movl $0x0, -0x24(%rbp)
cmpl $0x7, -0x24(%rbp)
jge 0x1658
xorl %edi, %edi
subl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x13f0
movq -0x18(%rbp), %rdi
callq 0x1320
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1630
movq -0x18(%rbp), %rdi
callq 0x16d0
leaq 0xa84(%rip), %rdi       # 0x20ec
movb $0x0, %al
callq 0x1040
movl $0x0, -0x28(%rbp)
cmpl $0x6, -0x28(%rbp)
jge 0x1699
movq -0x18(%rbp), %rdi
callq 0x1490
movq -0x18(%rbp), %rdi
callq 0x1320
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1676
movq -0x18(%rbp), %rdi
callq 0x16d0
leaq 0xa43(%rip), %rdi       # 0x20ec
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x11f0
movq -0x18(%rbp), %rdi
callq 0x1320
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/queue_array/queue.c
// Function: printInfo
static void printInfo(Queue q)
{
    if(q==NULL)
    {
        printf("queue is null.\n");
    }
    else
    {
        printf("Size: %d, Front: %d, End: %d\n",
               q->size,q->front,q->end);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x16f3
leaq 0xa1f(%rip), %rdi       # 0x2109
movb $0x0, %al
callq 0x1040
jmp 0x1716
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0xa0a(%rip), %rdi       # 0x2119
movb $0x0, %al
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wkoszek[P]mini_gzip/miniz.c
// Function: tdefl_create_comp_flags_from_zip_params
mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy)
{
  mz_uint comp_flags = s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0);
  if (window_bits > 0) comp_flags |= TDEFL_WRITE_ZLIB_HEADER;

  if (!level) comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS;
  else if (strategy == MZ_FILTERED) comp_flags |= TDEFL_FILTER_MATCHES;
  else if (strategy == MZ_HUFFMAN_ONLY) comp_flags &= ~TDEFL_MAX_PROBES_MASK;
  else if (strategy == MZ_FIXED) comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS;
  else if (strategy == MZ_RLE) comp_flags |= TDEFL_RLE_MATCHES;

  return comp_flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x1ef5
movl $0xa, %eax
cmpl -0x4(%rbp), %eax
jge 0x1ee7
movl $0xa, %eax
movl %eax, -0x14(%rbp)
jmp 0x1eed
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1eff
movl $0x6, %eax
movl %eax, -0x18(%rbp)
jmp 0x1eff
movl -0x18(%rbp), %eax
movslq %eax, %rcx
leaq 0xa604(%rip), %rax      # 0xc510
movl (%rax,%rcx,4), %eax
movl -0x4(%rbp), %esi
xorl %ecx, %ecx
movl $0x8000, %edx           # imm = 0x8000
cmpl $0x3, %esi
cmovlel %edx, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x1f35
movl -0x10(%rbp), %eax
orl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x1f48
movl -0x10(%rbp), %eax
orl $0x100000, %eax         # imm = 0x100000
movl %eax, -0x10(%rbp)
jmp 0x1f9a
cmpl $0x1, -0xc(%rbp)
jne 0x1f5b
movl -0x10(%rbp), %eax
orl $0x40000, %eax          # imm = 0x40000
movl %eax, -0x10(%rbp)
jmp 0x1f98
cmpl $0x2, -0xc(%rbp)
jne 0x1f6e
movl -0x10(%rbp), %eax
andl $0xfffff000, %eax       # imm = 0xFFFFF000
movl %eax, -0x10(%rbp)
jmp 0x1f96
cmpl $0x4, -0xc(%rbp)
jne 0x1f81
movl -0x10(%rbp), %eax
orl $0x80000, %eax          # imm = 0x80000
movl %eax, -0x10(%rbp)
jmp 0x1f94
cmpl $0x3, -0xc(%rbp)
jne 0x1f92
movl -0x10(%rbp), %eax
orl $0x20000, %eax          # imm = 0x20000
movl %eax, -0x10(%rbp)
jmp 0x1f94
jmp 0x1f96
jmp 0x1f98
jmp 0x1f9a
movl -0x10(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wkoszek[P]mini_gzip/miniz.c
// Function: mz_deflateEnd
int mz_deflateEnd(mz_streamp pStream)
{
  if (!pStream) return MZ_STREAM_ERROR;
  if (pStream->state)
  {
    pStream->zfree(pStream->opaque, pStream->state);
    pStream->state = NULL;
  }
  return MZ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x22ac
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x22e4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x22dd
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wkoszek[P]mini_gzip/miniz.c
// Function: mz_deflateReset
int mz_deflateReset(mz_streamp pStream)
{
  if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree)) return MZ_STREAM_ERROR;
  pStream->total_in = pStream->total_out = 0;
  tdefl_init((tdefl_compressor*)pStream->state, NULL, NULL, ((tdefl_compressor*)pStream->state)->m_flags);
  return MZ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2324
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x2324
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x2324
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x232d
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x236b
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x10(%rax), %ecx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x1ff0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wkoszek[P]mini_gzip/miniz.c
// Function: mz_compress2
int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level)
{
  int status;
  mz_stream stream;
  memset(&stream, 0, sizeof(stream));

  // In case mz_ulong is 64-bits (argh I hate longs).
  if ((source_len | *pDest_len) > 0xFFFFFFFFU) return MZ_PARAM_ERROR;

  stream.next_in = pSource;
  stream.avail_in = (mz_uint32)source_len;
  stream.next_out = pDest;
  stream.avail_out = (mz_uint32)*pDest_len;

  status = mz_deflateInit(&stream, level);
  if (status != MZ_OK) return status;

  status = mz_deflate(&stream, MZ_FINISH);
  if (status != MZ_STREAM_END)
  {
    mz_deflateEnd(&stream);
    return (status == MZ_OK) ? MZ_BUF_ERROR : status;
  }

  *pDest_len = stream.total_out;
  return mz_deflateEnd(&stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x78, %edx
callq 0x1090
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
orq (%rcx), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jbe 0x2ab3
movl $0xffffd8f0, -0x4(%rbp) # imm = 0xFFFFD8F0
jmp 0x2b67
movq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0xa0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x88(%rbp)
movl -0x2c(%rbp), %esi
leaq -0xa8(%rbp), %rdi
callq 0x1d00
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x2b00
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2b67
leaq -0xa8(%rbp), %rdi
movl $0x4, %esi
callq 0x2380
movl %eax, -0x30(%rbp)
cmpl $0x1, -0x30(%rbp)
je 0x2b4d
leaq -0xa8(%rbp), %rdi
callq 0x2290
cmpl $0x0, -0x30(%rbp)
jne 0x2b39
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
movl %eax, -0xac(%rbp)
jmp 0x2b42
movl -0x30(%rbp), %eax
movl %eax, -0xac(%rbp)
movl -0xac(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2b67
movq -0x80(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
leaq -0xa8(%rbp), %rdi
callq 0x2290
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wkoszek[P]mini_gzip/miniz.c
// Function: mz_inflateInit2
int mz_inflateInit2(mz_streamp pStream, int window_bits)
{
  inflate_state *pDecomp;
  if (!pStream) return MZ_STREAM_ERROR;
  if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)) return MZ_PARAM_ERROR;

  pStream->data_type = 0;
  pStream->adler = 0;
  pStream->crc32 = 0;
  pStream->msg = NULL;
  pStream->total_in = 0;
  pStream->total_out = 0;
  pStream->reserved = 0;
  if (!pStream->zalloc) pStream->zalloc = def_alloc_func;
  if (!pStream->zfree) pStream->zfree = def_free_func;

  pDecomp = (inflate_state*)pStream->zalloc(pStream->opaque, 1, sizeof(inflate_state));
  if (!pDecomp) return MZ_MEM_ERROR;

  pStream->state = (struct mz_internal_state *)pDecomp;

  tinfl_init(&pDecomp->m_decomp);
  pDecomp->m_dict_ofs = 0;
  pDecomp->m_dict_avail = 0;
  pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT;
  pDecomp->m_first_call = 1;
  pDecomp->m_has_flushed = 0;
  pDecomp->m_window_bits = window_bits;

  return MZ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2c02
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x2d45
cmpl $0xf, -0x14(%rbp)
je 0x2c1e
xorl %eax, %eax
subl -0x14(%rbp), %eax
cmpl $0xf, %eax
je 0x2c1e
movl $0xffffd8f0, -0x4(%rbp) # imm = 0xFFFFD8F0
jmp 0x2d45
movq -0x10(%rbp), %rax
movl $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x2c8b
movq -0x10(%rbp), %rax
leaq -0xce7(%rip), %rcx      # 0x1fa0
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x2ca5
movq -0x10(%rbp), %rax
leaq -0xcd1(%rip), %rcx      # 0x1fd0
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rdi
movl $0x1, %esi
movl $0xab18, %edx           # imm = 0xAB18
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2cd5
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x2d45
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x2b00(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x2b04(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0xab14(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x2b08(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x2b0c(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x2b10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wkoszek[P]mini_gzip/miniz.c
// Function: mz_uncompress
int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
{
  mz_stream stream;
  int status;
  memset(&stream, 0, sizeof(stream));

  // In case mz_ulong is 64-bits (argh I hate longs).
  if ((source_len | *pDest_len) > 0xFFFFFFFFU) return MZ_PARAM_ERROR;

  stream.next_in = pSource;
  stream.avail_in = (mz_uint32)source_len;
  stream.next_out = pDest;
  stream.avail_out = (mz_uint32)*pDest_len;

  status = mz_inflateInit(&stream);
  if (status != MZ_OK)
    return status;

  status = mz_inflate(&stream, MZ_FINISH);
  if (status != MZ_STREAM_END)
  {
    mz_inflateEnd(&stream);
    return ((status == MZ_BUF_ERROR) && (!stream.avail_in)) ? MZ_DATA_ERROR : status;
  }
  *pDest_len = stream.total_out;

  return mz_inflateEnd(&stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x78, %edx
callq 0x1090
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
orq (%rcx), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rax
jbe 0x606f
movl $0xffffd8f0, -0x4(%rbp) # imm = 0xFFFFD8F0
jmp 0x613b
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x80(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x2d50
movl %eax, -0xa4(%rbp)
cmpl $0x0, -0xa4(%rbp)
je 0x60bf
movl -0xa4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x613b
leaq -0xa0(%rbp), %rdi
movl $0x4, %esi
callq 0x2d70
movl %eax, -0xa4(%rbp)
cmpl $0x1, -0xa4(%rbp)
je 0x6121
leaq -0xa0(%rbp), %rdi
callq 0x5fc0
cmpl $-0x5, -0xa4(%rbp)
jne 0x610a
cmpl $0x0, -0x98(%rbp)
jne 0x610a
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
movl %eax, -0xa8(%rbp)
jmp 0x6116
movl -0xa4(%rbp), %eax
movl %eax, -0xa8(%rbp)
movl -0xa8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x613b
movq -0x78(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
leaq -0xa0(%rbp), %rdi
callq 0x5fc0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wkoszek[P]mini_gzip/miniz.c
// Function: tdefl_compress_mem_to_output
mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
{
  tdefl_compressor *pComp; mz_bool succeeded; if (((buf_len) && (!pBuf)) || (!pPut_buf_func)) return MZ_FALSE;
  pComp = (tdefl_compressor*)MZ_MALLOC(sizeof(tdefl_compressor)); if (!pComp) return MZ_FALSE;
  succeeded = (tdefl_init(pComp, pPut_buf_func, pPut_buf_user, flags) == TDEFL_STATUS_OKAY);
  succeeded = succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == TDEFL_STATUS_DONE);
  MZ_FREE(pComp); return succeeded;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8a8a
cmpq $0x0, -0x10(%rbp)
je 0x8a91
cmpq $0x0, -0x20(%rbp)
jne 0x8a9d
movl $0x0, -0x4(%rbp)
jmp 0x8b21
movl $0x4df80, %edi          # imm = 0x4DF80
callq 0x10e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x8abb
movl $0x0, -0x4(%rbp)
jmp 0x8b21
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x1ff0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x3c(%rbp)
movb %al, -0x3d(%rbp)
je 0x8b07
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x4, %ecx
callq 0x89d0
cmpl $0x1, %eax
sete %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1030
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wkoszek[P]mini_gzip/miniz.c
// Function: tdefl_compress_mem_to_heap
void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
{
  tdefl_output_buffer out_buf; MZ_CLEAR_OBJ(out_buf);
  if (!pOut_len) return MZ_FALSE; else *pOut_len = 0;
  out_buf.m_expandable = MZ_TRUE;
  if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags)) return NULL;
  *pOut_len = out_buf.m_size; return out_buf.m_pBuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1090
cmpq $0x0, -0x20(%rbp)
jne 0x8b68
movq $0x0, -0x8(%rbp)
jmp 0x8bb8
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x1, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %r8d
leaq 0x43(%rip), %rdx        # 0x8bd0
leaq -0x48(%rbp), %rcx
callq 0x8a60
cmpl $0x0, %eax
jne 0x8ba5
movq $0x0, -0x8(%rbp)
jmp 0x8bb8
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wkoszek[P]mini_gzip/miniz.c
// Function: tdefl_output_buffer_putter
static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len, void *pUser)
{
  tdefl_output_buffer *p = (tdefl_output_buffer *)pUser;
  size_t new_size = p->m_size + len;
  if (new_size > p->m_capacity)
  {
    size_t new_capacity = p->m_capacity; mz_uint8 *pNew_buf; if (!p->m_expandable) return MZ_FALSE;
    do { new_capacity = MZ_MAX(128U, new_capacity << 1U); } while (new_size > new_capacity);
    pNew_buf = (mz_uint8*)MZ_REALLOC(p->m_pBuf, new_capacity); if (!pNew_buf) return MZ_FALSE;
    p->m_pBuf = pNew_buf; p->m_capacity = new_capacity;
  }
  memcpy((mz_uint8*)p->m_pBuf + p->m_size, pBuf, len); p->m_size = new_size;
  return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x8ca9
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x8c31
movl $0x0, -0x4(%rbp)
jmp 0x8cd7
jmp 0x8c33
movq -0x38(%rbp), %rcx
shlq %rcx
movl $0x80, %eax
cmpq %rcx, %rax
jbe 0x8c4f
movl $0x80, %eax
movq %rax, -0x48(%rbp)
jmp 0x8c5a
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
ja 0x8c33
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x10f0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x8c91
movl $0x0, -0x4(%rbp)
jmp 0x8cd7
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rax
addq (%rax), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x10d0
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/wkoszek[P]mini_gzip/miniz.c
// Function: tdefl_compress_mem_to_mem
size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
{
  tdefl_output_buffer out_buf; MZ_CLEAR_OBJ(out_buf);
  if (!pOut_buf) return 0;
  out_buf.m_pBuf = (mz_uint8*)pOut_buf; out_buf.m_capacity = out_buf_len;
  if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags)) return 0;
  return out_buf.m_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1090
cmpq $0x0, -0x10(%rbp)
jne 0x8d1d
movq $0x0, -0x8(%rbp)
jmp 0x8d60
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %r8d
leaq -0x170(%rip), %rdx      # 0x8bd0
leaq -0x50(%rbp), %rcx
callq 0x8a60
cmpl $0x0, %eax
jne 0x8d58
movq $0x0, -0x8(%rbp)
jmp 0x8d60
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)