LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/fine-trie.c
// Function: search_and_squat
int search_and_squat  (const char *string, size_t strlen, int32_t ip4_address) {
    int32_t found;
    int rc;
    // Skip strings of length 0
    if (strlen == 0)
    return 0;

    // in case the node was removed between trying to insert and squatting
    rc = pthread_mutex_lock(&(root_lock));
    assert(rc == 0);
    if(root != NULL)
    {
      found = _insert(string, strlen, ip4_address, root, NULL, NULL);
    }
    else
    {
      root = new_leaf (string, strlen, ip4_address);
      found = 1;
    }
    rc = pthread_mutex_unlock(&(root_lock));
    assert(rc == 0);

    while(!found)
    {
      rc = pthread_mutex_lock(&(root->lock));
      assert(rc == 0);


      found = _search_and_squat(root, string, strlen, ip4_address);

      // in case the node was removed between trying to insert and squatting
      if(!found)
      {
        found = insert(string, strlen, ip4_address);
      }
    }



    return (found >= 0);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1b48
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x5600(%rip), %rdi      # 0x7118
callq 0x11d0
testl %eax, %eax
jne 0x1be3
movq 0x55e4(%rip), %rcx      # 0x7110
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
testq %rcx, %rcx
je 0x1b4c
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1c21
movl %eax, %ebp
jmp 0x1b5b
xorl %ebp, %ebp
jmp 0x1bb7
callq 0x12dc
movq %rax, 0x55b8(%rip)      # 0x7110
pushq $0x1
popq %rbp
leaq 0x55b6(%rip), %rdi      # 0x7118
callq 0x1110
testl %eax, %eax
jne 0x1c02
testl %ebp, %ebp
jne 0x1bb2
movq 0x5596(%rip), %rdi      # 0x7110
addq $0x58, %rdi
callq 0x11d0
testl %eax, %eax
jne 0x1bc4
movq 0x5582(%rip), %rdi      # 0x7110
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x172c
movl %eax, %ebp
testl %eax, %eax
jne 0x1b6f
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2457
movl %eax, %ebp
jmp 0x1b6f
notl %ebp
shrl $0x1f, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2542(%rip), %rdi      # 0x410d
leaq 0x2432(%rip), %rsi      # 0x4004
leaq 0x25d7(%rip), %rcx      # 0x41b0
movl $0x14b, %edx            # imm = 0x14B
callq 0x10b0
leaq 0x2523(%rip), %rdi      # 0x410d
leaq 0x2413(%rip), %rsi      # 0x4004
leaq 0x25b8(%rip), %rcx      # 0x41b0
movl $0x13b, %edx            # imm = 0x13B
callq 0x10b0
leaq 0x2504(%rip), %rdi      # 0x410d
leaq 0x23f4(%rip), %rsi      # 0x4004
leaq 0x2599(%rip), %rcx      # 0x41b0
movl $0x146, %edx            # imm = 0x146
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/fine-trie.c
// Function: insert
int insert (const char *string, size_t strlen, int32_t ip4_address) {
        // Skip strings of length 0
        int rc;
        if (strlen == 0)
        return 0;
        int rv;
        // get root lock
        rc = pthread_mutex_lock(&(root_lock));
        assert(rc == 0);
        if (root == NULL) {
          root = new_leaf (string, strlen, ip4_address);
          rv =  1;
          rc = pthread_mutex_unlock(&(root_lock));
          assert(rc == 0);
        }
        else
        {
          rv = _insert (string, strlen, ip4_address, root, NULL, NULL);
          rc = pthread_mutex_unlock(&(root_lock));
          assert(rc == 0);
          if (!rv && allow_squatting)
          {
            search_and_squat(string, strlen, ip4_address);
          }
        }
        return rv;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x24cd
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4ca6(%rip), %rdi      # 0x7118
callq 0x11d0
testl %eax, %eax
jne 0x2505
movq 0x4c8a(%rip), %rcx      # 0x7110
testq %rcx, %rcx
je 0x24d1
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1c21
movl %eax, %ebp
leaq 0x4c71(%rip), %rdi      # 0x7118
callq 0x1110
testl %eax, %eax
jne 0x2524
testl %ebp, %ebp
jne 0x24f8
leaq 0x4c85(%rip), %rax      # 0x7140
cmpl $0x0, (%rax)
je 0x24f8
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1afd
xorl %ebp, %ebp
jmp 0x24f8
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x12dc
movq %rax, 0x4c2b(%rip)      # 0x7110
leaq 0x4c2c(%rip), %rdi      # 0x7118
callq 0x1110
testl %eax, %eax
jne 0x2543
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c01(%rip), %rdi      # 0x410d
leaq 0x1af1(%rip), %rsi      # 0x4004
leaq 0x1d9a(%rip), %rcx      # 0x42b4
movl $0x262, %edx            # imm = 0x262
callq 0x10b0
leaq 0x1be2(%rip), %rdi      # 0x410d
leaq 0x1ad2(%rip), %rsi      # 0x4004
leaq 0x1d7b(%rip), %rcx      # 0x42b4
movl $0x26d, %edx            # imm = 0x26D
callq 0x10b0
leaq 0x1bc3(%rip), %rdi      # 0x410d
leaq 0x1ab3(%rip), %rsi      # 0x4004
leaq 0x1d5c(%rip), %rcx      # 0x42b4
movl $0x267, %edx            # imm = 0x267
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/fine-trie.c
// Function: delete
int delete  (const char *string, size_t strlen) {
          // Skip strings of length 0
          if (strlen == 0)
          return 0;
          int rc;

          rc = pthread_mutex_lock(&root_lock);
          assert(rc == 0);
          struct trie_node *parent = _delete(root, string, strlen);

          rc = pthread_mutex_unlock(&root_lock);
          assert(rc == 0);
          // release root lock

          int rv =(NULL != parent);

          if(parent != NULL && parent != ((struct trie_node *) 0x100100))
          {
            rc = pthread_mutex_unlock(&(parent->lock));
            assert(rc == 0);

          }


          return rv;
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x2b00
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4687(%rip), %rdi      # 0x7118
callq 0x11d0
testl %eax, %eax
jne 0x2b0b
movq 0x466f(%rip), %rdi      # 0x7110
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2562
movq %rax, %rbx
leaq 0x4662(%rip), %rdi      # 0x7118
callq 0x1110
testl %eax, %eax
jne 0x2b2a
testq %rbx, %rbx
setne %bpl
je 0x2b02
cmpq $0x100100, %rbx         # imm = 0x100100
je 0x2b02
addq $0x58, %rbx
movq %rbx, %rdi
callq 0x1110
testl %eax, %eax
je 0x2b02
leaq 0x1625(%rip), %rdi      # 0x410d
leaq 0x1515(%rip), %rsi      # 0x4004
leaq 0x1858(%rip), %rcx      # 0x434e
movl $0x35f, %edx            # imm = 0x35F
callq 0x10b0
xorl %ebp, %ebp
movzbl %bpl, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x15fb(%rip), %rdi      # 0x410d
leaq 0x14eb(%rip), %rsi      # 0x4004
leaq 0x182e(%rip), %rcx      # 0x434e
movl $0x353, %edx            # imm = 0x353
callq 0x10b0
leaq 0x15dc(%rip), %rdi      # 0x410d
leaq 0x14cc(%rip), %rsi      # 0x4004
leaq 0x180f(%rip), %rcx      # 0x434e
movl $0x357, %edx            # imm = 0x357
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/fine-trie.c
// Function: print
void print() {
          // TODO get root lock
          printf ("Root is at %p\n", root);
          struct trie_node *node = root;
          // relese root lock

          if(node)
          {
            _print(node,0 ,0);
          }
        }

// Assembly:
pushq %rax
movq 0x44a5(%rip), %rsi      # 0x7110
leaq 0x179a(%rip), %rdi      # 0x440c
xorl %eax, %eax
callq 0x10a0
movq 0x4490(%rip), %rdi      # 0x7110
testq %rdi, %rdi
je 0x2c8f
xorl %esi, %esi
xorl %edx, %edx
popq %rax
jmp 0x2b49
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_02/read.c
// Function: main
int main(void)
{
	int fd;
	int nr, nw;
	char buf[BUF_SIZE];

	fd = open(TMP_FILE, O_RDONLY);
	if (fd < 0) {
		perror("open");
		return -1;
	}

	do {
		nr = read(fd, buf, BUF_SIZE);
		if (nr < 0) {
			perror("read");
			return -1;
		}

		nw = writen(STDOUT_FILENO, buf, nr);
		if (nw < nr) {
			perror("write");
			return -1;
		}

		sleep(1);
	} while (nr > 0);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0xe65(%rip), %rdi       # 0x2004
xorl %esi, %esi
xorl %eax, %eax
callq 0x1060
testl %eax, %eax
js 0x1200
movl %eax, %ebx
movq %rsp, %r14
pushq $0x10
popq %r15
pushq $0x1
popq %rbp
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
movq %rax, %r12
testl %r12d, %r12d
js 0x1209
movl %r12d, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl %ebp, %edi
movq %r14, %rsi
callq 0x127f
cmpl %r12d, %eax
jl 0x1212
movl %ebp, %edi
callq 0x1080
testl %r12d, %r12d
jne 0x11b8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe07(%rip), %rdi       # 0x200e
jmp 0x1219
leaq 0xe03(%rip), %rdi       # 0x2013
jmp 0x1219
leaq 0xdff(%rip), %rdi       # 0x2018
callq 0x1070
pushq $-0x1
popq %rax
jmp 0x11f3
nop
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_02/wrappers.c
// Function: readn
int readn(int fd, void *buf, size_t count)
{
        int nleft = count, nread;
        char *ptr = buf;

        while (nleft > 0) {
                nread = read(fd, ptr, nleft);
                if (nread < 0) {
                        if (errno != EAGAIN)
                                return -1;
                        nread = 0;
                } else if (nread == 0)
                        break;

                nleft -= nread;
                ptr += nread;
        }

        return count - nleft;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
pushq $-0x1
popq %rbp
movl %ebx, %r12d
testl %r12d, %r12d
jle 0x126f
movl %r12d, %edx
movl %r15d, %edi
movq %r14, %rsi
callq 0x1050
testl %eax, %eax
js 0x1256
jne 0x1265
jmp 0x126f
callq 0x1030
movq %rax, %rcx
xorl %eax, %eax
cmpl $0xb, (%rcx)
jne 0x1274
subl %eax, %r12d
movl %eax, %eax
addq %rax, %r14
jmp 0x123b
subl %r12d, %ebx
movl %ebx, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/giometti[P]mastering_UNIX_programming/chapter_02/wrappers.c
// Function: writen
int writen(int fd, void *buf, size_t count)
{
        int nleft = count, nwritten;
        char *ptr = buf;

        while (nleft > 0) {
                nwritten = write(fd, ptr, nleft);
                if (nwritten < 0) {
                        if (errno != EAGAIN)
                                return -1;
                        nwritten = 0;
                }

                nleft -= nwritten;
                ptr += nwritten;
        }

        return count - nleft;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
pushq $-0x1
popq %rbp
movl %ebx, %r12d
testl %r12d, %r12d
jle 0x12c6
movl %r12d, %edx
movl %r15d, %edi
movq %r14, %rsi
callq 0x1040
testl %eax, %eax
jns 0x12bc
callq 0x1030
movq %rax, %rcx
xorl %eax, %eax
cmpl $0xb, (%rcx)
jne 0x12cb
subl %eax, %r12d
movl %eax, %eax
addq %rax, %r14
jmp 0x1296
subl %r12d, %ebx
movl %ebx, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/joncampbell123[P]swfhax/c4_swf2svg.c
// Function: dump_font_to_svg
void dump_font_to_svg(swf_reader *swf,swf_DefineFont *nfo) {
	unsigned int i;
	uint64_t ofs;
	FILE *fp;

	for (i=0;i < nfo->nGlyphs;i++) {
		ofs = (unsigned long long)nfo->absoluteOffsetTable + (unsigned long long)nfo->OffsetTable[i];
		if (swf_reader_seek(swf,ofs) == 0) {
			char tmp[256];

			sprintf(tmp,"swf.font.%u.glyph.%u.svg",nfo->FontID,i);
			fp = fopen(tmp,"w");
			if (fp) do_dump_font_to_svg(swf,fp);
			fclose(fp);
		}
		else {
			fprintf(stderr,"!! Unable to seek to offset (likely reason: non-sequential offsets)\n");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x130(%rbp), %r12
xorl %r15d, %r15d
movzwl 0x2(%rbx), %eax
cmpq %rax, %r15
jae 0x156b
movq 0x8(%rbx), %rax
movzwl (%rax,%r15,2), %esi
addq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x2f85
testl %eax, %eax
jne 0x154d
movzwl (%rbx), %edx
movq %r12, %rdi
leaq 0x4cd7(%rip), %rsi      # 0x61eb
movl %r15d, %ecx
xorl %eax, %eax
callq 0x11a0
movq %r12, %rdi
leaq 0x4cdc(%rip), %rsi      # 0x6204
callq 0x1180
movq %rax, %r13
testq %rax, %rax
je 0x1540
movq %r14, %rdi
movq %r13, %rsi
callq 0x12bc
movq %r13, %rdi
callq 0x1060
incq %r15
jmp 0x14e5
movq 0x8aa4(%rip), %rax      # 0x9ff8
movq (%rax), %rcx
leaq 0x4ca8(%rip), %rdi      # 0x6206
pushq $0x44
popq %rsi
pushq $0x1
popq %rdx
callq 0x11b0
jmp 0x1548
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]yasuna/src/libbenly/src/column.c
// Function: tablize
int tablize(char** const array[])
{
    int     status  = 0;

    size_t  x       = 0,
            y       = 0,
        *   length  = NULL;

    regex_t reg;

    y = count_lines(array);
    x = count_cols(array);
    if (regcomp(&reg, ANSI_ESCSEQ, REG_EXTENDED) != 0) {
        status = -1; goto ERR;
    }
    if (count_length(array, x, y, &length, &reg) < 0) {
        status = -2; goto ERR;
    }
    put(array, x, y, length, &reg);
    regfree(&reg);
    free(length);

    return 0;

ERR:
    switch (status) {
        case    -1:
            break;
        case    -2:
            regfree(&reg);
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbp
pushq $-0x1
popq %rbx
cmpq $0x0, 0x8(%rbp,%rbx,8)
leaq 0x1(%rbx), %rbx
jne 0x11d0
movq (%rbp), %rax
pushq $-0x1
popq %r13
pushq $0x8
popq %r14
addq $-0x8, %r14
cmpq $0x0, 0x8(%rax,%r13,8)
leaq 0x1(%r13), %r13
jne 0x11e8
leaq 0xe01(%rip), %rsi       # 0x2000
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0x10a0
testl %eax, %eax
je 0x1218
pushq $-0x1
popq %rax
jmp 0x133a
negq %r14
movq %r14, %rdi
callq 0x10b0
movq %rax, (%rsp)
testq %rax, %rax
je 0x1349
xorl %r14d, %r14d
cmpq %r14, %r13
je 0x1280
movq (%rsp), %rax
andq $0x0, (%rax,%r14,8)
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x127b
movq (%rbp,%r12,8), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x127b
leaq 0x18(%rsp), %rsi
callq 0x135a
cltq
cmpq %rax, %r15
jae 0x1276
movq (%rsp), %rcx
movq %rax, (%rcx,%r14,8)
movq %rax, %r15
incq %r12
jmp 0x1247
incq %r14
jmp 0x1233
xorl %r15d, %r15d
pushq $0x20
popq %r12
movq %r13, 0x10(%rsp)
movq %rbx, 0x8(%rsp)
cmpq %r15, %rbx
je 0x1325
xorl %r14d, %r14d
cmpq %r14, %r13
je 0x1315
movq (%rbp,%r15,8), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x1315
movq 0x2d29(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x1090
movq %r15, %rax
movq %rbp, %r15
movq %rax, %rbx
movq (%rbp,%rax,8), %rax
movq (%rax,%r14,8), %rdi
leaq 0x18(%rsp), %rsi
callq 0x135a
movslq %eax, %r13
movq (%rsp), %rax
movq (%rax,%r14,8), %rbp
decq %r13
incq %r13
cmpq %rbp, %r13
ja 0x12fd
movl %r12d, %edi
callq 0x1040
testl %eax, %eax
jne 0x12e9
incq %r14
movq 0x8(%rsp), %rax
movq %r15, %rbp
movq 0x10(%rsp), %r13
movq %rbx, %r15
movq %rax, %rbx
jmp 0x129d
pushq $0xa
popq %rdi
callq 0x1040
incq %r15
jmp 0x1291
leaq 0x18(%rsp), %rdi
callq 0x1070
movq (%rsp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rsp), %rdi
callq 0x1070
pushq $-0x2
jmp 0x1212
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]yasuna/src/libbenly/src/column.c
// Function: mbstrlen_with_regex
static
int mbstrlen_with_regex(char* src, regex_t* reg)
{
    int         ch      = 0,
                len     = 0;

    char*       p       = src;

#ifdef  WITH_GLIB
    gunichar*   cpoints;
/* WITH_GLIB */
#endif

    regmatch_t  match;

    setlocale(LC_CTYPE, LOCALE);

    while (*p != '\0') {
        /* get string length */
        if ((ch = mblen(p, MB_CUR_MAX)) < 0)
            return 0;

#ifdef  WITH_GLIB
        /*
         * true : multi byte
         * false: ascii
         */
        if (ch > 1) {
            /* get unicode code point */
            cpoints = g_utf8_to_ucs4_fast(p, sizeof(*p), NULL);
            /*
             * # multi byte
             * true : hankaku kana
             * false: other
             */
            if ((*cpoints >= 0xff65 && *cpoints <= 0xff9f) ||
                    *cpoints == 0x001b) {
                len++;
            } else {
                len += 2;
            }
            g_free(cpoints);
        } else {
            len++;
        }
#else
        /*
         * true : multi byte
         * false: ascii
         */
        if (ch > 1) {
            len += 2;
        } else {
            len++;
        }
/* WITH_GLIB */
#endif
        /* seek offset */
        p += ch;
    }

    /* regex match */
    while (regexec(reg, src, 1, &match, 0) != REG_NOMATCH) {
        src += match.rm_eo;
        len -= match.rm_eo - match.rm_so;
    }

    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc9f(%rip), %rsi       # 0x2011
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x10d0
movq %r15, %r13
cmpb $0x0, (%r13)
je 0x13e3
callq 0x1080
movq %r13, %rdi
movq %rax, %rsi
callq 0x1050
testl %eax, %eax
js 0x1412
movl %eax, %ebp
pushq $0x1
popq %r12
cmpl $0x2, %eax
jb 0x13d9
movq %r13, %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x10e0
movl (%rax), %ecx
leal -0xff65(%rcx), %edx
cmpl $0x3b, %edx
setb %dl
cmpl $0x1b, %ecx
sete %cl
orb %dl, %cl
movzbl %cl, %ecx
pushq $0x2
popq %r12
subl %ecx, %r12d
movq %rax, %rdi
callq 0x1060
addl %r12d, %ebx
movl %ebp, %eax
addq %rax, %r13
jmp 0x137e
pushq $0x1
popq %r12
movq %rsp, %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0x10c0
cmpl $0x1, %eax
je 0x1414
movslq 0x4(%rsp), %rax
addq %rax, %r15
subl %eax, %ebx
addl (%rsp), %ebx
jmp 0x13ea
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/misc.c
// Function: fml_opt_init
void fml_opt_init(fml_opt_t *opt)
{
	opt->n_threads = 1;
	opt->ec_k = 0;
	opt->min_cnt = 4;
	opt->max_cnt = 8;
	opt->min_asm_ovlp = 33;
	opt->min_merge_len = 0;
	mag_init_opt(&opt->mag_opt);
	opt->mag_opt.flag = MAG_F_NO_SIMPL | MAG_F_POPOPEN;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movaps 0x11cfd(%rip), %xmm0    # 0x14370
movups %xmm0, (%rdi)
movq $0x21, 0x10(%rdi)
addq $0x18, %rdi
callq 0xfae6
movl $0xc0, 0x18(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/misc.c
// Function: fml_opt_adjust
void fml_opt_adjust(fml_opt_t *opt, int n_seqs, const bseq1_t *seqs)
{
	int i, log_len;
	uint64_t tot_len = 0;
	if (opt->n_threads < 1) opt->n_threads = 1;
	for (i = 0; i < n_seqs; ++i) tot_len += seqs[i].l_seq; // compute total length
	for (log_len = 10; log_len < 32; ++log_len) // compute ceil(log2(tot_len))
		if (1ULL<<log_len > tot_len) break;
	if (opt->ec_k == 0) opt->ec_k = (log_len + 12) / 2;
	if (opt->ec_k%2 == 0) ++opt->ec_k;
	opt->mag_opt.min_elen = (int)((double)tot_len / n_seqs * 2.5 + .499);
}

// Assembly:
cmpl $0x0, (%rdi)
jg 0x269b
movl $0x1, (%rdi)
xorl %ecx, %ecx
testl %esi, %esi
movl $0x0, %eax
cmovgl %esi, %eax
imulq $0x18, %rax, %r8
xorl %eax, %eax
cmpq %rcx, %r8
je 0x26bf
movslq (%rdx,%rcx), %r9
addq %r9, %rax
addq $0x18, %rcx
jmp 0x26ad
pushq $0xa
popq %rdx
movq %rdx, %rcx
movq %rax, %r8
shrq %cl, %r8
incq %rdx
cmpq $0x1f, %rcx
ja 0x26d9
testq %r8, %r8
jne 0x26c2
movl 0x4(%rdi), %ecx
testl %ecx, %ecx
jne 0x26ea
addl $0xb, %edx
shrl %edx
movl %edx, 0x4(%rdi)
movl %edx, %ecx
testb $0x1, %cl
jne 0x26f5
orl $0x1, %ecx
movl %ecx, 0x4(%rdi)
movq %rax, %xmm0
punpckldq 0x11c7e(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x11c86(%rip), %xmm0    # 0x14390
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cvtsi2sd %esi, %xmm0
divsd %xmm0, %xmm1
mulsd 0x11c7a(%rip), %xmm1    # 0x143a0
addsd 0x11c7a(%rip), %xmm1    # 0x143a8
cvttsd2si %xmm1, %eax
movl %eax, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/misc.c
// Function: fml_mag_clean
void fml_mag_clean(const fml_opt_t *opt, struct mag_t *g)
{
	magopt_t o = opt->mag_opt;
	o.min_merge_len = opt->min_merge_len;
	mag_g_merge(g, 1, opt->min_merge_len);
	mag_g_clean(g, &o);
	mag_g_trim_open(g, &o);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq 0x48(%rdi), %rax
movq %rsp, %r14
movq %rax, 0x30(%r14)
movups 0x18(%rdi), %xmm0
movups 0x28(%rdi), %xmm1
movups 0x38(%rdi), %xmm2
movaps %xmm2, 0x20(%r14)
movaps %xmm1, 0x10(%r14)
movaps %xmm0, (%r14)
movl 0x14(%rdi), %edx
movl %edx, 0x20(%r14)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xe1ca
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfb2e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfdf2
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/misc.c
// Function: fml_utg_print_gfa
void fml_utg_print_gfa(int n, const fml_utg_t *utg)
{
	int i, j;
	FILE *fp = stdout;
	fputs("H\tVN:Z:1.0\n", fp);
	for (i = 0; i < n; ++i) {
		const fml_utg_t *u = &utg[i];
		fprintf(fp, "S\t%d\t", i);
		fputs(u->seq, fp);
		fprintf(fp, "\tLN:i:%d\tRC:i:%d\tPD:Z:", u->len, u->nsr);
		fputs(u->cov, fp);
		fputc('\n', fp);
		for (j = 0; j < u->n_ovlp[0] + u->n_ovlp[1]; ++j) {
			fml_ovlp_t *o = &u->ovlp[j];
			if (i < o->id)
				fprintf(fp, "L\t%d\t%c\t%d\t%c\t%dM\n", i, "+-"[!o->from], o->id, "+-"[o->to], o->len);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movl %edi, %ebx
movq 0x17e26(%rip), %rax     # 0x1afc0
movq (%rax), %r15
leaq 0x11263(%rip), %rdi     # 0x14407
movq %r15, %rsi
callq 0x20f0
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
movq %rbx, 0x10(%rsp)
leaq 0x11284(%rip), %r14     # 0x14443
xorl %r13d, %r13d
cmpq 0x10(%rsp), %r13
je 0x32a6
imulq $0x28, %r13, %r12
movq 0x8(%rsp), %rbp
leaq (%r12,%rbp), %rbx
movq %r15, %rdi
leaq 0x1122f(%rip), %rsi     # 0x14413
movl %r13d, %edx
xorl %eax, %eax
callq 0x2150
movq 0x8(%rbp,%r12), %rdi
movq %r15, %rsi
callq 0x20f0
movl (%rbp,%r12), %edx
movl 0x4(%rbp,%r12), %ecx
movq %r15, %rdi
leaq 0x1120a(%rip), %rsi     # 0x14419
xorl %eax, %eax
callq 0x2150
movq 0x10(%rbp,%r12), %rdi
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movq %r15, %rsi
callq 0x20f0
pushq $0xa
popq %rdi
movq %r15, %rsi
callq 0x2120
xorl %r12d, %r12d
movslq 0x18(%rbx), %rax
movslq 0x1c(%rbx), %rcx
addq %rax, %rcx
cmpq %rcx, %r12
jge 0x329e
movq 0x20(%rbx), %rax
movq (%rax,%r12,8), %rax
movq %rax, %r8
shrq $0x20, %r8
movl %r8d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpq %rcx, %r13
jae 0x3299
andl %ebp, %r8d
movl %eax, %ecx
shrl $0x1f, %ecx
xorq $0x1, %rcx
movsbl (%rcx,%r14), %ecx
movq %rax, %rdx
shrq $0x3f, %rdx
movsbl (%rdx,%r14), %r9d
andl %ebp, %eax
movl %eax, (%rsp)
movq %r15, %rdi
leaq 0x111a1(%rip), %rsi     # 0x14430
movl %r13d, %edx
xorl %eax, %eax
callq 0x2150
incq %r12
jmp 0x3236
incq %r13
jmp 0x31c2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/misc.c
// Function: fml_utg_destroy
void fml_utg_destroy(int n, fml_utg_t *utg)
{
	int i;
	for (i = 0; i < n; ++i) {
		free(utg[i].seq);
		free(utg[i].cov);
		free(utg[i].ovlp);
	}
	free(utg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
xorl %r14d, %r14d
testl %edi, %edi
cmovlel %r14d, %edi
imulq $0x28, %rdi, %r15
cmpq %r14, %r15
je 0x32f3
movq 0x8(%rbx,%r14), %rdi
callq 0x2040
movq 0x10(%rbx,%r14), %rdi
callq 0x2040
movq 0x20(%rbx,%r14), %rdi
callq 0x2040
addq $0x28, %r14
jmp 0x32ca
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/misc.c
// Function: fml_assemble
fml_utg_t *fml_assemble(const fml_opt_t *opt0, int n_seqs, bseq1_t *seqs, int *n_utg)
{
	rld_t *e;
	mag_t *g;
	fml_utg_t *utg;
	fml_opt_t opt = *opt0;
	float kcov;

	*n_utg = 0;
	fml_opt_adjust(&opt, n_seqs, seqs);
	if (opt.ec_k >= 0) fml_correct(&opt, n_seqs, seqs);
	kcov = fml_fltuniq(&opt, n_seqs, seqs);
	e = fml_seq2fmi(&opt, n_seqs, seqs);
	if (e == 0) return 0; // this may happen when all sequences are filtered out
	g = fml_fmi2mag(&opt, e);
	opt.mag_opt.min_ensr = opt.mag_opt.min_ensr > kcov * MAG_MIN_NSR_COEF? opt.mag_opt.min_ensr : (int)(kcov * MAG_MIN_NSR_COEF + .499);
	opt.mag_opt.min_ensr = opt.mag_opt.min_ensr < opt0->max_cnt? opt.mag_opt.min_ensr : opt0->max_cnt;
	opt.mag_opt.min_ensr = opt.mag_opt.min_ensr > opt0->min_cnt? opt.mag_opt.min_ensr : opt0->min_cnt;
	opt.mag_opt.min_insr = opt.mag_opt.min_ensr - 1;
	fml_mag_clean(&opt, g);
	utg = fml_mag2utg(g, n_utg);
	return utg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
pushq $0x14
popq %rcx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
rep  movsl (%rsi), %es:(%rdi)
andl $0x0, (%rbx)
movq %r12, %rdi
movl %ebp, %esi
callq 0x2690
cmpl $0x0, 0x4(%r12)
js 0x334b
leaq 0x10(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x61bd
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x61c9
movss %xmm0, 0xc(%rsp)
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x2a81
testq %rax, %rax
je 0x33e5
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xa965
movl 0x24(%r15), %ecx
cvtsi2sd %ecx, %xmm0
cvtss2sd 0xc(%rsp), %xmm1
mulsd 0x11015(%rip), %xmm1    # 0x143b0
ucomisd %xmm1, %xmm0
addsd 0x11001(%rip), %xmm1    # 0x143a8
cvttsd2si %xmm1, %edx
cmoval %ecx, %edx
movl 0xc(%r14), %ecx
cmpl %ecx, %edx
cmovgel %ecx, %edx
movl 0x8(%r14), %ecx
cmpl %ecx, %edx
cmovlel %ecx, %edx
movq %rax, %r14
movl %edx, 0x24(%r15)
decl %edx
movl %edx, 0x28(%r15)
movq %r15, %rdi
movq %rax, %rsi
callq 0x2a9a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2afe
jmp 0x33e7
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/bseq.c
// Function: seq_reverse
void seq_reverse(int l, unsigned char *s)
{
	int i;
	for (i = 0; i < l>>1; ++i) {
		int tmp = s[l-1-i];
		s[l-1-i] = s[i]; s[i] = tmp;
	}
}

// Assembly:
movl %edi, %eax
sarl %eax
cltq
decl %edi
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x37bd
movslq %edi, %rdi
movb (%rsi,%rdi), %dl
movb (%rsi,%rcx), %r8b
movb %r8b, (%rsi,%rdi)
movb %dl, (%rsi,%rcx)
incq %rcx
decl %edi
jmp 0x37a0
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/bseq.c
// Function: seq_revcomp6
void seq_revcomp6(int l, unsigned char *s)
{
	int i;
	for (i = 0; i < l>>1; ++i) {
		int tmp = s[l-1-i];
		tmp = (tmp >= 1 && tmp <= 4)? 5 - tmp : tmp;
		s[l-1-i] = (s[i] >= 1 && s[i] <= 4)? 5 - s[i] : s[i];
		s[i] = tmp;
	}
	if (l&1) s[i] = (s[i] >= 1 && s[i] <= 4)? 5 - s[i] : s[i];
}

// Assembly:
movl %edi, %eax
sarl %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
leal -0x1(%rdi), %edx
cmpq %rcx, %rax
je 0x3819
movslq %edx, %rdx
movzbl (%rsi,%rdx), %r8d
movb $0x5, %r9b
subb %r8b, %r9b
leal -0x1(%r8), %r10d
cmpb $0x4, %r10b
movzbl %r9b, %r9d
cmovael %r8d, %r9d
movzbl (%rsi,%rcx), %r8d
movb $0x5, %r10b
subb %r8b, %r10b
leal -0x1(%r8), %r11d
cmpb $0x4, %r11b
movzbl %r10b, %r10d
cmovael %r8d, %r10d
movb %r10b, (%rsi,%rdx)
movb %r9b, (%rsi,%rcx)
incq %rcx
decl %edx
jmp 0x37cc
testb $0x1, %dil
je 0x3837
movzbl (%rsi,%rax), %ecx
movb $0x5, %dl
subb %cl, %dl
leal -0x1(%rcx), %edi
cmpb $0x4, %dil
movzbl %dl, %edx
cmovael %ecx, %edx
movb %dl, (%rsi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/bfc.c
// Function: fml_count
struct bfc_ch_s *fml_count(int n, const bseq1_t *seq, int k, int q, int l_pre, int n_threads)
{
	int i;
	cnt_step_t cs;
	cs.n_seqs = n, cs.seqs = seq, cs.k = k, cs.q = q;
	cs.ch = bfc_ch_init(cs.k, l_pre);
	cs.n_buf = calloc(n_threads, sizeof(int));
	cs.buf = calloc(n_threads, sizeof(void*));
	for (i = 0; i < n_threads; ++i)
		cs.buf[i] = malloc(CNT_BUF_SIZE * sizeof(insbuf_t));
	kt_for(n_threads, worker_count, &cs, cs.n_seqs);
	for (i = 0; i < n_threads; ++i) free(cs.buf[i]);
	free(cs.buf); free(cs.n_buf);
	return cs.ch;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %r9d, %ebx
movl %edi, %ebp
movl %edi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, (%rsp)
movl %ecx, 0x4(%rsp)
movl %edx, %edi
movl %r8d, %esi
callq 0x11d24
movq %rax, 0x18(%rsp)
movslq %ebx, %r15
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x2130
movq %rax, 0x20(%rsp)
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x2130
movq %rax, %r14
movq %rax, 0x28(%rsp)
xorl %r12d, %r12d
testl %r15d, %r15d
movl $0x0, %r15d
cmovgl %ebx, %r15d
cmpq %r12, %r15
je 0x3ba5
movl $0x1800, %edi           # imm = 0x1800
callq 0x21a0
movq %rax, (%r14,%r12,8)
incq %r12
jmp 0x3b8d
movslq %ebp, %rcx
leaq 0x45(%rip), %rsi        # 0x3bf4
movq %rsp, %rdx
movl %ebx, %edi
callq 0x11b74
xorl %ebx, %ebx
movq 0x28(%rsp), %rdi
cmpq %rbx, %r15
je 0x3bd3
movq (%rdi,%rbx,8), %rdi
callq 0x2040
incq %rbx
jmp 0x3bbb
callq 0x2040
movq 0x20(%rsp), %rdi
callq 0x2040
movq 0x18(%rsp), %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/bfc.c
// Function: bfc_ec_greedy_k
int bfc_ec_greedy_k(int k, int mode, const bfc_kmer_t *x, const bfc_ch_t *ch)
{
	int i, j, max = 0, max_ec = -1, max2 = 0;
	for (i = 0; i < k; ++i) {
		int c = (x->x[1]>>i&1)<<1 | (x->x[0]>>i&1);
		for (j = 0; j < 4; ++j) {
			bfc_kmer_t y = *x;
			int ret;
			if (j == c) continue;
			bfc_kmer_change(k, y.x, i, j);
			ret = bfc_ch_kmer_occ(ch, &y);
			if (ret < 0) continue;
			if ((max&0xff) < (ret&0xff)) max2 = max, max = ret, max_ec = i<<2 | j;
			else if ((max2&0xff) < (ret&0xff)) max2 = ret;
		}
	}
	return (max&0xff) * 3 > mode && (max2&0xff) < 3? max_ec : -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, 0x48(%rsp)
movq %rdx, %r15
movq $0x0, 0x10(%rsp)
testl %edi, %edi
movl $0x0, %eax
movl %edi, 0x1c(%rsp)
cmovgl %edi, %eax
movq %rax, 0x40(%rsp)
movl %esi, 0x18(%rsp)
pushq $-0x1
popq %rax
movl %eax, 0xc(%rsp)
xorl %r9d, %r9d
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq 0x40(%rsp), %r9
je 0x3fc7
movq (%r15), %rax
movq 0x8(%r15), %rdx
pushq $-0x2
popq %rsi
movq %rsi, %rdi
movl %r9d, %ecx
rolq %cl, %rdi
movq %rdi, 0x60(%rsp)
movl %r9d, %ecx
notl %ecx
addl 0x1c(%rsp), %ecx
movq %rcx, 0x50(%rsp)
rolq %cl, %rsi
movq %rsi, 0x58(%rsp)
xorl %ecx, %ecx
btq %r9, %rdx
setb %cl
xorl %edx, %edx
btq %r9, %rax
setb %dl
leal (%rdx,%rcx,2), %ebx
xorl %r12d, %r12d
cmpl $0x4, %r12d
je 0x3fb2
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
cmpl %r12d, %ebx
jne 0x3ed9
movl %r13d, %eax
movl %ebp, %r13d
jmp 0x3fa4
movl %r12d, %eax
andl $0x1, %eax
movq %rax, %rsi
movl %r9d, %ecx
shlq %cl, %rsi
movq 0x20(%rsp), %rdi
movq 0x60(%rsp), %r10
andq %r10, %rdi
movl %r12d, %edx
shrl %edx
movq %rdx, %r8
movq %r9, %r14
shlq %cl, %r8
orq %rsi, %rdi
movq %rdi, 0x20(%rsp)
movq 0x28(%rsp), %rcx
andq %r10, %rcx
orq %r8, %rcx
movq %rcx, 0x28(%rsp)
xorl $0x1, %eax
movq 0x50(%rsp), %rcx
shlq %cl, %rax
movq 0x30(%rsp), %rdi
movq 0x58(%rsp), %rsi
andq %rsi, %rdi
orq %rax, %rdi
movq %rdi, 0x30(%rsp)
xorl $0x1, %edx
shlq %cl, %rdx
movq 0x38(%rsp), %rax
andq %rsi, %rax
orq %rdx, %rax
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x12195
testl %eax, %eax
js 0x3f87
movl %r13d, %edx
movl $0xff, %esi
andl %esi, %edx
movl %eax, %ecx
andl %esi, %ecx
cmpl %ecx, %edx
movq %r14, %r9
jae 0x3f92
movq 0x10(%rsp), %rcx
addl %r12d, %ecx
movl %ecx, 0xc(%rsp)
jmp 0x3fa4
movl %r13d, %eax
movl %ebp, %r13d
movq %r14, %r9
jmp 0x3fa4
movzbl %bpl, %edx
cmpl %ecx, %edx
jb 0x3f9c
movl %ebp, %eax
movl %eax, %ecx
movl %r13d, %eax
movl %ecx, %r13d
movl %r13d, %ebp
incl %r12d
movl %eax, %r13d
jmp 0x3eac
incq %r9
movq 0x10(%rsp), %rax
addl $0x4, %eax
movq %rax, 0x10(%rsp)
jmp 0x3e5b
movl $0xff, %eax
andl %eax, %r13d
leal (%r13,%r13,2), %ecx
andl %eax, %ebp
cmpl $0x3, %ebp
pushq $-0x1
popq %rdx
movl 0xc(%rsp), %eax
cmovael %edx, %eax
cmpl 0x18(%rsp), %ecx
cmovlel %edx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/bfc.c
// Function: bfc_ec_first_kmer
int bfc_ec_first_kmer(int k, const ecseq_t *s, int start, bfc_kmer_t *x)
{
	int i, l;
	*x = bfc_kmer_null;
	for (i = start, l = 0; i < s->n; ++i) {
		ecbase_t *c = &s->a[i];
		if (c->b < 4) {
			bfc_kmer_append(k, x->x, c->b);
			if (++l == k) break;
		} else l = 0, *x = bfc_kmer_null;
	}
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movups 0x17280(%rip), %xmm0    # 0x1b290
movups %xmm0, 0x10(%rcx)
movups 0x17265(%rip), %xmm0    # 0x1b280
movups %xmm0, (%rcx)
movslq %edx, %r15
xorl %r12d, %r12d
cmpq %r15, (%r14)
jbe 0x406b
movq 0x10(%r14), %rax
movzbl (%rax,%r15,8), %edx
andl $0x7, %edx
cmpb $0x3, %dl
ja 0x404e
movl %ebp, %edi
movq %rbx, %rsi
callq 0x4077
incl %r12d
cmpl %ebp, %r12d
jne 0x4066
jmp 0x406b
movups 0x1723b(%rip), %xmm0    # 0x1b290
movups %xmm0, 0x10(%rbx)
movups 0x17220(%rip), %xmm0    # 0x1b280
movups %xmm0, (%rbx)
xorl %r12d, %r12d
incq %r15
jmp 0x4024
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/./kmer.h
// Function: bfc_kmer_append
static inline void bfc_kmer_append(int k, uint64_t x[4], int c)
{ // IMPORTANT: 0 <= c < 4
	uint64_t mask = (1ULL<<k) - 1;
	x[0] = (x[0]<<1 | (c&1))  & mask;
	x[1] = (x[1]<<1 | (c>>1)) & mask;
	x[2] = x[2]>>1 | (1ULL^(c&1))<<(k-1);
	x[3] = x[3]>>1 | (1ULL^c>>1) <<(k-1);
}

// Assembly:
movl %edi, %ecx
pushq $-0x1
popq %rdi
shlq %cl, %rdi
notq %rdi
movl %edx, %eax
andl $0x1, %eax
movq (%rsi), %r8
movq 0x8(%rsi), %r9
leaq (%rax,%r8,2), %r8
andq %rdi, %r8
movq %r8, (%rsi)
addq %r9, %r9
sarl %edx
movslq %edx, %rdx
orq %rdx, %r9
andq %rdi, %r9
movq %r9, 0x8(%rsi)
movq 0x10(%rsi), %rdi
xorq $0x1, %rax
decl %ecx
shlq %cl, %rax
shrq %rdi
orq %rdi, %rax
movq %rax, 0x10(%rsi)
xorq $0x1, %rdx
shlq %cl, %rdx
movq 0x18(%rsi), %rax
shrq %rax
orq %rax, %rdx
movq %rdx, 0x18(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/bfc.c
// Function: bfc_ec_kcov
void bfc_ec_kcov(int k, int min_occ, ecseq_t *s, const bfc_ch_t *ch)
{
	int i, l, r, j;
	bfc_kmer_t x = bfc_kmer_null;
	for (i = l = 0; i < s->n; ++i) {
		ecbase_t *c = &s->a[i];
		c->high_end = c->solid_end = c->lcov = c->hcov = 0;
		if (c->b < 4) {
			bfc_kmer_append(k, x.x, c->b);
			if (++l >= k) {
				if ((r = bfc_ch_kmer_occ(ch, &x)) >= 0) {
					if ((r>>8&0x3f) >= min_occ+1) c->high_end = 1;
					if ((r&0xff) >= min_occ) {
						c->solid_end = 1;
						for (j = i - k + 1; j <= i; ++j)
							++s->a[j].lcov, s->a[j].hcov += c->high_end;
					}
				}
			}
		} else l = 0, x = bfc_kmer_null;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x18(%rsp)
movq %rdx, %r14
movl %esi, 0x10(%rsp)
movups 0x17198(%rip), %xmm0    # 0x1b290
leaq 0x20(%rsp), %r15
movaps %xmm0, 0x10(%r15)
movups 0x17177(%rip), %xmm0    # 0x1b280
movaps %xmm0, (%r15)
movl %edi, 0x14(%rsp)
movl %edi, %r9d
negl %r9d
xorl %ebx, %ebx
xorl %r13d, %r13d
movl 0x14(%rsp), %ebp
cmpq %rbx, (%r14)
jbe 0x4225
movq 0x10(%r14), %r12
andw $0xc000, 0x2(%r12,%rbx,8) # imm = 0xC000
movzbl (%r12,%rbx,8), %edx
andl $0x7, %edx
cmpb $0x3, %dl
ja 0x41f3
movl %r9d, 0xc(%rsp)
movl %ebp, %edi
movq %r15, %rsi
callq 0x4077
incl %r13d
cmpl %ebp, %r13d
jl 0x4215
movq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x12195
testl %eax, %eax
js 0x4210
movl %eax, %ecx
shrl $0x8, %ecx
andl $0x3f, %ecx
cmpl 0x10(%rsp), %ecx
movl 0xc(%rsp), %r9d
jle 0x418f
orb $0x20, 0x3(%r12,%rbx,8)
movzbl %al, %eax
cmpl 0x10(%rsp), %eax
leaq 0x20(%rsp), %r15
jl 0x421a
movslq %r9d, %rax
orb $0x10, 0x3(%r12,%rbx,8)
cmpq %rbx, %rax
jge 0x421a
movq 0x10(%r14), %rcx
movzwl 0xa(%rcx,%rax,8), %edx
leal 0x1(%rdx), %edi
andl $0x3f, %edi
andl $-0x40, %edx
orl %edi, %edx
movw %dx, 0xa(%rcx,%rax,8)
movzwl 0x2(%r12,%rbx,8), %ecx
movq 0x10(%r14), %rdx
movzwl 0xa(%rdx,%rax,8), %edi
shrl $0x7, %ecx
andl $0x40, %ecx
addl %edi, %ecx
andl $0xfc0, %ecx            # imm = 0xFC0
andl $0xfffff03f, %edi       # imm = 0xFFFFF03F
orl %ecx, %edi
movw %di, 0xa(%rdx,%rax,8)
incq %rax
jmp 0x41a6
movups 0x17096(%rip), %xmm0    # 0x1b290
movaps %xmm0, 0x30(%rsp)
movups 0x1707a(%rip), %xmm0    # 0x1b280
movaps %xmm0, 0x20(%rsp)
xorl %r13d, %r13d
jmp 0x421a
leaq 0x20(%rsp), %r15
movl 0xc(%rsp), %r9d
incq %rbx
incl %r9d
jmp 0x4120
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/bfc.c
// Function: bfc_ec_best_island
uint64_t bfc_ec_best_island(int k, const ecseq_t *s)
{ // IMPORTANT: call bfc_ec_kcov() before calling this function!
	int i, l, max, max_i;
	for (i = k - 1, max = l = 0, max_i = -1; i < s->n; ++i) {
		if (!s->a[i].solid_end) {
			if (l > max) max = l, max_i = i;
			l = 0;
		} else ++l;
	}
	if (l > max) max = l, max_i = i;
	return max > 0? (uint64_t)(max_i - max - k + 1) << 32 | max_i : 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leal -0x1(%rdi), %eax
movq (%rsi), %rdx
movslq %eax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %r10d, %r10d
movq %rcx, %r11
xorl %r9d, %r9d
xorl %r8d, %r8d
cmpq %r11, %rdx
jbe 0x4287
movq 0x10(%rsi), %rbx
leal 0x1(%r9), %ebp
cmpl %r8d, %r9d
cmovlel %r8d, %r9d
movl %eax, %r14d
cmovgl %r11d, %r14d
testb $0x10, 0x3(%rbx,%r11,8)
cmovel %r10d, %ebp
cmovel %r9d, %r8d
cmovel %r14d, %eax
incq %r11
movl %ebp, %r9d
jmp 0x4252
cmpl %r8d, %r9d
movl %r8d, %esi
cmovgl %r9d, %esi
testl %esi, %esi
jle 0x42b6
cmpq %rcx, %rdx
cmovaq %rdx, %rcx
cmpl %r8d, %r9d
cmovgl %ecx, %eax
addl %edi, %esi
negl %esi
leal (%rax,%rsi), %ecx
incl %ecx
shlq $0x20, %rcx
cltq
orq %rcx, %rax
jmp 0x42b8
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/bfc.c
// Function: bfc_seq_revcomp
static void bfc_seq_revcomp(ecseq_t *seq)
{
	int i;
	for (i = 0; i < seq->n>>1; ++i) {
		ecbase_t tmp;
		tmp = ecbase_comp(&seq->a[i]);
		seq->a[i] = ecbase_comp(&seq->a[seq->n - 1 - i]);
		seq->a[seq->n - 1 - i] = tmp;
	}
	if (seq->n&1) seq->a[i] = ecbase_comp(&seq->a[i]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $-0x8
popq %r12
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rbp
movq %rbp, %rax
shrq %rax
cmpq %r15, %rax
jbe 0x5cc2
movq 0x10(%rbx), %r13
leaq (%r14,%r13), %rdi
callq 0x64a7
movq %rax, (%rsp)
leaq (%r12,%rbp,8), %rdi
addq %r13, %rdi
callq 0x64a7
movq %rax, (%r13,%r14)
movq (%rbx), %rax
shlq $0x3, %rax
addq 0x10(%rbx), %rax
movq (%rsp), %rdx
movq %rdx, (%r12,%rax)
incq %r15
addq $0x8, %r14
addq $-0x8, %r12
jmp 0x5c72
testb $0x1, %bpl
je 0x5cd9
movq 0x10(%rbx), %rbx
leaq (%rbx,%r14), %rdi
callq 0x64a7
movq %rax, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/bfc.c
// Function: bfc_kmer_bufclear
static int bfc_kmer_bufclear(cnt_step_t *cs, int forced, int tid)
{
	int i, k, r;
	if (cs->ch == 0) return 0;
	for (i = k = 0; i < cs->n_buf[tid]; ++i) {
		r = bfc_ch_insert(cs->ch, cs->buf[tid][i].y, cs->buf[tid][i].is_high, forced);
		if (r < 0) cs->buf[tid][k++] = cs->buf[tid][i];
	}
	cs->n_buf[tid] = k;
	return k;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x18(%rdi)
je 0x6257
movl %esi, %ebx
movq %rdi, %r14
movslq %edx, %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x20(%r14), %rax
movslq (%rax,%r15,4), %rcx
cmpq %rcx, %r13
jge 0x6251
movq 0x18(%r14), %rdi
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rsi
movl 0x10(%rsi,%r12), %edx
addq %r12, %rsi
movl %ebx, %ecx
callq 0x11e67
testl %eax, %eax
jns 0x6248
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rax
movslq %ebp, %rcx
incl %ebp
imulq $0x18, %rcx, %rcx
movq 0x10(%rax,%r12), %rdx
movq %rdx, 0x10(%rax,%rcx)
movups (%rax,%r12), %xmm0
movups %xmm0, (%rax,%rcx)
incq %r13
addq $0x18, %r12
jmp 0x61f8
movl %ebp, (%rax,%r15,4)
jmp 0x6259
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/./kmer.h
// Function: bfc_hash_64
static inline uint64_t bfc_hash_64(uint64_t key, uint64_t mask)
{
	key = (~key + (key << 21)) & mask; // key = (key << 21) - key - 1;
	key = key ^ key >> 24;
	key = ((key + (key << 3)) + (key << 8)) & mask; // key * 265
	key = key ^ key >> 14;
	key = ((key + (key << 2)) + (key << 4)) & mask; // key * 21
	key = key ^ key >> 28;
	key = (key + (key << 31)) & mask;
	return key;
}

// Assembly:
movq %rdi, %rax
notq %rax
shlq $0x15, %rdi
addq %rax, %rdi
andq %rsi, %rdi
movq %rdi, %rax
shrq $0x18, %rax
xorq %rdi, %rax
imulq $0x109, %rax, %rax      # imm = 0x109
andq %rsi, %rax
movq %rax, %rcx
shrq $0xe, %rcx
xorq %rax, %rcx
imulq $0x15, %rcx, %rax
andq %rsi, %rax
movq %rax, %rcx
shrq $0x1c, %rcx
xorq %rax, %rcx
movl $0x80000001, %eax       # imm = 0x80000001
imulq %rcx, %rax
andq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/bfc.c
// Function: ecbase_comp
static inline ecbase_t ecbase_comp(const ecbase_t *b)
{
	ecbase_t r = *b;
	r.b = b->b < 4? 3 - b->b : 4;
	r.ob = b->ob < 4? 3 - b->ob : 4;
	return r;
}

// Assembly:
movb (%rdi), %al
movzwl 0x5(%rdi), %edx
movzbl 0x7(%rdi), %ecx
shll $0x10, %ecx
orl %edx, %ecx
movl 0x1(%rdi), %edx
movl %eax, %esi
andb $0x7, %sil
movb $0x3, %dil
subb %sil, %dil
cmpb $0x4, %sil
movzbl %dil, %esi
pushq $0x4
popq %rdi
cmovbl %esi, %edi
movl %eax, %esi
shrb $0x4, %sil
andb $0x7, %sil
movl %esi, %r8d
shlb $0x4, %r8b
movb $0x30, %r9b
subb %r8b, %r9b
cmpb $0x4, %sil
movzbl %r9b, %esi
pushq $0x40
popq %r8
cmovbl %esi, %r8d
andb $-0x78, %al
orb %dil, %al
orb %r8b, %al
shlq $0x28, %rcx
shlq $0x8, %rdx
orq %rcx, %rdx
movzbl %al, %eax
orq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mrope.c
// Function: mr_init
mrope_t *mr_init(int max_nodes, int block_len, int sorting_order)
{
	int a;
	mrope_t *r;
	assert(sorting_order >= 0 && sorting_order <= 2);
	r = calloc(1, sizeof(mrope_t));
	r->so = sorting_order;
	r->thr_min = 1000;
	for (a = 0; a != 6; ++a)
		r->r[a] = rope_init(max_nodes, block_len);
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x3, %edx
jae 0x6568
movl %edx, %r12d
movl %esi, %ebx
movl %edi, %ebp
pushq $0x1
popq %r14
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x2130
movq %rax, %r15
movb %r12b, (%rax)
movl $0x3e8, 0x4(%rax)       # imm = 0x3E8
cmpq $0x7, %r14
je 0x655c
movl %ebp, %edi
movl %ebx, %esi
callq 0x12544
movq %rax, (%r15,%r14,8)
incq %r14
jmp 0x6544
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe062(%rip), %rdi      # 0x145d1
leaq 0xe084(%rip), %rsi      # 0x145fa
leaq 0xe085(%rip), %rcx      # 0x14602
pushq $0x12
popq %rdx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mrope.c
// Function: mr_destroy
void mr_destroy(mrope_t *r)
{
	int a;
	for (a = 0; a != 6; ++a)
		if (r->r[a]) rope_destroy(r->r[a]);
	free(r);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r14
cmpq $0x7, %r14
je 0x65a9
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x65a4
callq 0x1269c
incq %r14
jmp 0x6590
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mrope.c
// Function: mr_insert1
int64_t mr_insert1(mrope_t *r, const uint8_t *str)
{
	int64_t tl[6], tu[6], l, u;
	const uint8_t *p;
	int b, is_srt = (r->so != MR_SO_IO), is_comp = (r->so == MR_SO_RCLO);
	for (u = 0, b = 0; b != 6; ++b) u += r->r[b]->c[0];
	l = is_srt? 0 : u;
	for (p = str, b = 0; *p; b = *p++) {
		int a;
		if (l != u) {
			int64_t cnt = 0;
			rope_rank2a(r->r[b], l, u, tl, tu);
			if (is_comp && *p != 5) {
				for (a = 4; a > *p; --a) l += tu[a] - tl[a];
				l += tu[0] - tl[0];
			} else for (a = 0; a < *p; ++a) l += tu[a] - tl[a];
			rope_insert_run(r->r[b], l, *p, 1, 0);
			while (--b >= 0) cnt += r->r[b]->c[*p];
			l = cnt + tl[*p]; u = cnt + tu[*p];
		} else {
			l = rope_insert_run(r->r[b], l, *p, 1, 0);
			while (--b >= 0) l += r->r[b]->c[*p];
			u = l;
		}
	}
	return rope_insert_run(r->r[b], l, 0, 1, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb (%rdi), %al
movb %al, 0xf(%rsp)
pushq $0x1
popq %rcx
xorl %eax, %eax
cmpq $0x7, %rcx
je 0x65f8
movq (%rbx,%rcx,8), %rdx
addq 0x8(%rdx), %rax
incq %rcx
jmp 0x65e5
xorl %ecx, %ecx
cmpb $0x0, 0xf(%rsp)
movl $0x0, %ebp
cmoveq %rax, %rbp
pushq $0x1
popq %r15
movzbl (%r14), %edx
movl %ecx, %r13d
testl %edx, %edx
je 0x670a
movq 0x8(%rbx,%r13,8), %rdi
cmpq %rax, %rbp
jne 0x6655
movq %rax, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x126f1
testq %r13, %r13
jle 0x664a
movq (%rbx,%r13,8), %rcx
decq %r13
movzbl (%r14), %edx
addq 0x8(%rcx,%rdx,8), %rax
jmp 0x6633
movb (%r14), %cl
movq %rax, %rbp
jmp 0x66ff
cmpb $0x2, 0xf(%rsp)
setne %r12b
movq %rbp, %rsi
movq %rax, %rdx
leaq 0x40(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x12c58
movzbl (%r14), %eax
cmpq $0x5, %rax
sete %cl
orb %r12b, %cl
je 0x6699
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x66ba
addq 0x10(%rsp,%rcx,8), %rbp
subq 0x40(%rsp,%rcx,8), %rbp
incq %rcx
jmp 0x6685
pushq $0x4
popq %rcx
cmpq %rax, %rcx
jbe 0x66b0
addq 0x10(%rsp,%rcx,8), %rbp
subq 0x40(%rsp,%rcx,8), %rbp
decq %rcx
jmp 0x669c
addq 0x10(%rsp), %rbp
subq 0x40(%rsp), %rbp
movzbl %al, %edx
movq 0x8(%rbx,%r13,8), %rdi
movq %rbp, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x126f1
xorl %eax, %eax
testq %r13, %r13
jle 0x66e9
movq (%rbx,%r13,8), %rcx
decq %r13
movzbl (%r14), %edx
addq 0x8(%rcx,%rdx,8), %rax
jmp 0x66d2
movzbl (%r14), %ecx
movl %ecx, %edx
shll $0x3, %edx
movq 0x40(%rsp,%rdx), %rbp
addq %rax, %rbp
addq 0x10(%rsp,%rdx), %rax
incq %r14
movzbl %cl, %ecx
jmp 0x660c
movq 0x8(%rbx,%r13,8), %rdi
pushq $0x1
popq %rcx
movq %rbp, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x126f1
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mrope.c
// Function: mr_itr_next_block
const uint8_t *mr_itr_next_block(mritr_t *i)
{
	const uint8_t *s;
	if (i->a >= 6) return 0;
	while ((s = rope_itr_next_block(&i->i)) == 0) {
		if (i->to_free) {
			rope_destroy(i->r->r[i->a]);
			i->r->r[i->a] = 0;
		}
		if (++i->a == 6) return 0;
		rope_itr_first(i->r->r[i->a], &i->i);
	}
	return i->a == 6? 0 : s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x5, 0x8(%rdi)
jle 0x6991
xorl %ebx, %ebx
jmp 0x69fb
movq %rdi, %r14
leaq 0x10(%rdi), %r15
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x12e9e
testq %rax, %rax
jne 0x69ed
cmpl $0x0, 0xc(%r14)
movl 0x8(%r14), %eax
je 0x69ce
cltq
movq (%r14), %rcx
movq 0x8(%rcx,%rax,8), %rdi
callq 0x1269c
movq (%r14), %rcx
movslq 0x8(%r14), %rax
andq $0x0, 0x8(%rcx,%rax,8)
incl %eax
movl %eax, 0x8(%r14)
cmpl $0x6, %eax
je 0x69fb
movq (%r14), %rcx
cltq
movq 0x8(%rcx,%rax,8), %rdi
movq %r15, %rsi
callq 0x12e52
jmp 0x699a
xorl %ecx, %ecx
cmpl $0x6, 0x8(%r14)
cmoveq %rcx, %rax
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]fermi-lite/mrope.c
// Function: worker
static void *worker(void *data)
{
	worker_t *w = (worker_t*)data;
	struct timespec req, rem;
	req.tv_sec = 0; req.tv_nsec = 1000000;
	do {
		while (!__sync_bool_compare_and_swap(&w->to_run, 1, 0)) nanosleep(&req, &rem); // wait for the signal from the master thread
		if (w->m) mr_insert_multi_aux(w->mr->r[w->b], w->m, w->a, w->is_comp);
		__sync_add_and_fetch(w->n_fin_workers, 1);
	} while (!w->to_exit);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
andq $0x0, (%r14)
movq $0xf4240, 0x8(%r14)     # imm = 0xF4240
pushq $0x1
popq %rbp
xorl %r12d, %r12d
movq %rsp, %r15
movl %ebp, %eax
lock
cmpxchgl %r12d, 0x8(%rbx)
jne 0x734d
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x733f
movq 0x10(%rbx), %rax
movslq 0x18(%rbx), %rcx
movq 0x8(%rax,%rcx,8), %rdi
movq 0x28(%rbx), %rdx
movl 0x1c(%rbx), %ecx
callq 0x6f81
movq (%rbx), %rax
lock
incl (%rax)
cmpl $0x0, 0xc(%rbx)
je 0x7313
jmp 0x735a
movq %r14, %rdi
movq %r15, %rsi
callq 0x20d0
jmp 0x7313
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)