LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/htslib/regidx.c
// Function: regidx_destroy
void regidx_destroy(regidx_t *idx)
{
    int i, j;
    for (i=0; i<idx->nseq; i++)
    {
        reglist_t *list = &idx->seq[i];
        if ( idx->free )
        {
            for (j=0; j<list->nregs; j++)
                idx->free(list->payload + idx->payload_size*j);
        }
        free(list->payload);
        free(list->regs);
        free(list->idx);
    }
    free(idx->seq_names);
    free(idx->seq);
    free(idx->str.s);
    free(idx->payload);
    khash_str2int_destroy_free(idx->seq2regs);
    free(idx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x173bb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x17387
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x17385
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rdi
movq -0x8(%rbp), %rcx
movl 0x5c(%rcx), %ecx
imull -0x10(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rdi
callq *%rax
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1734b
jmp 0x17387
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3370
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3370
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3370
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x17313
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3370
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3370
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x3370
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x3370
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x17410
movq -0x8(%rbp), %rdi
callq 0x3370
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/htslib/cram/cram_io.c
// Function: get_int_threadid
static unsigned get_int_threadid() {
    pthread_t pt = pthread_self();
    unsigned char *s = (unsigned char *) &pt;
    size_t i;
    unsigned h = 0;
    for (i = 0; i < sizeof(pthread_t); i++)
	h = (h << 5) - h + s[i];
    return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x34c0
movq %rax, -0x8(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x8, -0x18(%rbp)
jae 0x2bf67
movl -0x1c(%rbp), %eax
shll $0x5, %eax
subl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2bf38
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/htslib/bgzf.c
// Function: deflate_block
static int deflate_block(BGZF *fp, int block_length)
{
    size_t comp_size = BGZF_MAX_BLOCK_SIZE;
    int ret;
    if ( !fp->is_gzip )
        ret = bgzf_compress(fp->compressed_block, &comp_size, fp->uncompressed_block, block_length, fp->compress_level);
    else
        ret = bgzf_gzip_compress(fp, fp->compressed_block, &comp_size, fp->uncompressed_block, block_length, fp->compress_level);

    if ( ret != 0 )
    {
        if (hts_verbose >= 3) {
            fprintf(stderr, "[E::%s] compression error %d\n", __func__, ret);
        }
        fp->errcode |= BGZF_ERR_ZLIB;
        return -1;
    }
    fp->block_offset = 0;
    return comp_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x10000, -0x20(%rbp)   # imm = 0x10000
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
jne 0x3bcc6
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rax
movl (%rax), %r8d
shll $0x3, %r8d
sarl $0x17, %r8d
leaq -0x20(%rbp), %rsi
callq 0x39e30
movl %eax, -0x24(%rbp)
jmp 0x3bcf9
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0x14(%rbp), %r8
movq -0x10(%rbp), %rax
movl (%rax), %r9d
shll $0x3, %r9d
sarl $0x17, %r9d
leaq -0x20(%rbp), %rdx
callq 0x3e4c0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x3bd57
leaq 0x4978a(%rip), %rax     # 0x85490
cmpl $0x3, (%rax)
jl 0x3bd2d
movq 0x492d6(%rip), %rax     # 0x84fe8
movq (%rax), %rdi
movl -0x24(%rbp), %ecx
leaq 0x3c9a3(%rip), %rsi     # 0x786c2
leaq 0x3c9ba(%rip), %rdx     # 0x786e0
movb $0x0, %al
callq 0x37f0
movq -0x10(%rbp), %rax
movl (%rax), %edx
andl $0xffff, %edx           # imm = 0xFFFF
orl $0x1, %edx
movl (%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3bd69
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/htslib/bgzf.c
// Function: bgzf_gzip_compress
static int bgzf_gzip_compress(BGZF *fp, void *_dst, size_t *dlen, const void *src, size_t slen, int level)
{
    uint8_t *dst = (uint8_t*)_dst;
    z_stream *zs = fp->gz_stream;
    int flush = slen ? Z_NO_FLUSH : Z_FINISH;
    zs->next_in   = (Bytef*)src;
    zs->avail_in  = slen;
    zs->next_out  = dst;
    zs->avail_out = *dlen;
    int ret = deflate(zs, flush);
    if (ret == Z_STREAM_ERROR) {
        if (hts_verbose >= 1) {
            fprintf(stderr, "[E::%s] deflate failed: %s\n",
                    __func__, bgzf_zerr(ret, NULL));
        }
        return -1;
    }
    *dlen = *dlen - zs->avail_out;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdx
movl $0x4, %eax
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x4c(%rbp)
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x3200
movl %eax, -0x50(%rbp)
cmpl $-0x2, -0x50(%rbp)
jne 0x3e59d
leaq 0x46f37(%rip), %rax     # 0x85490
cmpl $0x1, (%rax)
jl 0x3e594
movq 0x46a83(%rip), %rax     # 0x84fe8
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movl -0x50(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x3a130
movq -0x58(%rbp), %rdi
movq %rax, %rcx
leaq 0x39c4d(%rip), %rsi     # 0x781d3
leaq 0x3a161(%rip), %rdx     # 0x786ee
movb $0x0, %al
callq 0x37f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3e5bc
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x48(%rbp), %rax
movl 0x20(%rax), %eax
subq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/htslib/faidx.c
// Function: fai_read
static faidx_t *fai_read(FILE *fp, const char *fname)
{
    faidx_t *fai;
    char *buf, *p;
    int len, line_len, line_blen;
#ifdef _WIN32
    long offset;
#else
    long long offset;
#endif
    fai = (faidx_t*)calloc(1, sizeof(faidx_t));
    fai->hash = kh_init(s);
    buf = (char*)calloc(0x10000, 1);
    while (fgets(buf, 0x10000, fp)) {
        for (p = buf; *p && isgraph(*p); ++p);
        *p = 0; ++p;
#ifdef _WIN32
        sscanf(p, "%d%ld%d%d", &len, &offset, &line_blen, &line_len);
#else
        sscanf(p, "%d%lld%d%d", &len, &offset, &line_blen, &line_len);
#endif
        if (fai_insert_index(fai, buf, len, line_len, line_blen, offset) != 0) {
            free(buf);
            return NULL;
        }
    }
    free(buf);
    if (ferror(fp)) {
        fprintf(stderr, "[fai_load] error while reading \"%s\": %s\n", fname, strerror(errno));
        fai_destroy(fai);
        return NULL;
    }
    return fai;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x36b0
movq %rax, -0x20(%rbp)
callq 0x3ea40
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x10000, %edi          # imm = 0x10000
movl $0x1, %esi
callq 0x36b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x10000, %esi          # imm = 0x10000
callq 0x32e0
cmpq $0x0, %rax
je 0x3f935
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x49(%rbp)
je 0x3f8af
callq 0x3410
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x3f8b8
jmp 0x3f8c8
jmp 0x3f8ba
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3f87a
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x392f9(%rip), %rsi     # 0x78bdf
leaq -0x34(%rbp), %rdx
leaq -0x48(%rbp), %rcx
leaq -0x3c(%rbp), %r8
leaq -0x38(%rbp), %r9
movb $0x0, %al
callq 0x3140
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %ecx
movl -0x3c(%rbp), %r8d
movq -0x48(%rbp), %r9
callq 0x3ea60
cmpl $0x0, %eax
je 0x3f930
movq -0x28(%rbp), %rdi
callq 0x3370
movq $0x0, -0x8(%rbp)
jmp 0x3f9a2
jmp 0x3f856
movq -0x28(%rbp), %rdi
callq 0x3370
movq -0x10(%rbp), %rdi
callq 0x33b0
cmpl $0x0, %eax
je 0x3f99a
movq 0x45695(%rip), %rax     # 0x84fe8
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x35d0
movl (%rax), %edi
callq 0x34e0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
movq %rax, %rcx
leaq 0x3926a(%rip), %rsi     # 0x78bea
movb $0x0, %al
callq 0x37f0
movq -0x20(%rbp), %rdi
callq 0x3eec0
movq $0x0, -0x8(%rbp)
jmp 0x3f9a2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/htslib/hfile.c
// Function: find_scheme_handler
static const struct hFILE_scheme_handler *find_scheme_handler(const char *s)
{
    static const struct hFILE_scheme_handler unknown_scheme =
        { hopen_unknown_scheme, hfile_always_local, "built-in", 0 };

    char scheme[12];
    int i;

    for (i = 0; i < sizeof scheme; i++)
        if (isalnum_c(s[i]) || s[i] == '+' || s[i] == '-' || s[i] == '.')
            scheme[i] = tolower_c(s[i]);
        else if (s[i] == ':') break;
        else return NULL;

    if (i == 0 || i >= sizeof scheme) return NULL;
    scheme[i] = '\0';

    pthread_mutex_lock(&plugins_lock);
    if (! schemes) load_hfile_plugins();
    pthread_mutex_unlock(&plugins_lock);

    khint_t k = kh_get(scheme_string, schemes, scheme);
    return (k != kh_end(schemes))? kh_value(schemes, k) : &unknown_scheme;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
cmpq $0xc, %rax
jae 0x41d67
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x42760
cmpl $0x0, %eax
jne 0x41d1a
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2b, %eax
je 0x41d1a
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
je 0x41d1a
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
jne 0x41d37
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x42790
movb %al, %cl
movslq -0x20(%rbp), %rax
movb %cl, -0x1c(%rbp,%rax)
jmp 0x41d57
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0x41d4a
jmp 0x41d67
movq $0x0, -0x8(%rbp)
jmp 0x41dff
jmp 0x41d59
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x41cc3
cmpl $0x0, -0x20(%rbp)
je 0x41d77
movslq -0x20(%rbp), %rax
cmpq $0xc, %rax
jb 0x41d81
movq $0x0, -0x8(%rbp)
jmp 0x41dff
movslq -0x20(%rbp), %rax
movb $0x0, -0x1c(%rbp,%rax)
leaq 0x43a07(%rip), %rdi     # 0x85798
callq 0x37b0
cmpq $0x0, 0x439f2(%rip)     # 0x85790
jne 0x41da5
callq 0x42900
leaq 0x439ec(%rip), %rdi     # 0x85798
callq 0x3850
movq 0x439d8(%rip), %rdi     # 0x85790
leaq -0x1c(%rbp), %rsi
callq 0x427b0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq 0x439c2(%rip), %rcx     # 0x85790
cmpl (%rcx), %eax
je 0x41dea
movq 0x439b7(%rip), %rax     # 0x85790
movq 0x20(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
jmp 0x41df7
leaq 0x42ecf(%rip), %rax     # 0x84cc0
movq %rax, -0x30(%rbp)
jmp 0x41df7
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/htslib/hfile.c
// Function: hfile_exit
static void hfile_exit()
{
    pthread_mutex_lock(&plugins_lock);

    kh_destroy(scheme_string, schemes);

    while (plugins != NULL) {
        struct hFILE_plugin_list *p = plugins;
        if (p->plugin.destroy) p->plugin.destroy();
#ifdef ENABLE_PLUGINS
        if (p->plugin.obj) close_plugin(p->plugin.obj);
#endif
        plugins = p->next;
        free(p);
    }

    pthread_mutex_unlock(&plugins_lock);
    pthread_mutex_destroy(&plugins_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x429d9(%rip), %rdi     # 0x85798
callq 0x37b0
movq 0x429c5(%rip), %rdi     # 0x85790
callq 0x42e30
cmpq $0x0, 0x429e8(%rip)     # 0x857c0
je 0x42e11
movq 0x429df(%rip), %rax     # 0x857c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x42df7
movq -0x8(%rbp), %rax
callq *0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x429ba(%rip)     # 0x857c0
movq -0x8(%rbp), %rdi
callq 0x3370
jmp 0x42dd0
leaq 0x42980(%rip), %rdi     # 0x85798
callq 0x3850
leaq 0x42974(%rip), %rdi     # 0x85798
callq 0x3800
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/htslib/hfile_net.c
// Function: hfile_plugin_init_net
int hfile_plugin_init_net(struct hFILE_plugin *self)
{
    static const struct hFILE_scheme_handler handler =
        { hopen_net, hfile_always_remote, "knetfile", 0 };

    self->name = "knetfile";
    hfile_add_scheme_handler("http", &handler);
    hfile_add_scheme_handler("ftp",  &handler);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x35cb5(%rip), %rcx     # 0x78c1c
movq %rcx, 0x10(%rax)
leaq 0x35d3c(%rip), %rdi     # 0x78cae
leaq 0x41df7(%rip), %rsi     # 0x84d70
callq 0x41860
leaq 0x35d2e(%rip), %rdi     # 0x78cb3
leaq 0x41de4(%rip), %rsi     # 0x84d70
callq 0x41860
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/htslib/sam.c
// Function: bam_plp_destroy
void bam_plp_destroy(bam_plp_t iter)
{
    lbnode_t *p, *pnext;
    if ( iter->overlaps ) kh_destroy(olap_hash, iter->overlaps);
    for (p = iter->head; p != NULL; p = pnext) {
        pnext = p->next;
        mp_free(iter->mp, p);
    }
    mp_destroy(iter->mp);
    if (iter->b) bam_destroy1(iter->b);
    free(iter->plp);
    free(iter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x4b3a4
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b420
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4b3dd
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4b470
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x4b3b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4b520
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x4b401
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x45180
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3370
movq -0x8(%rbp), %rdi
callq 0x3370
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/htslib/knetfile.c
// Function: knet_read
ssize_t knet_read(knetFile *fp, void *buf, size_t len)
{
	off_t l = 0;
	if (fp->fd == -1) return 0;
	if (fp->type == KNF_TYPE_FTP) {
		if (fp->is_ready == 0) {
			if (!fp->no_reconnect) kftp_reconnect(fp);
			kftp_connect_file(fp);
		}
	} else if (fp->type == KNF_TYPE_HTTP) {
		if (fp->is_ready == 0)
			khttp_connect_file(fp);
	}
	if (fp->type == KNF_TYPE_LOCAL) { // on Windows, the following block is necessary; not on UNIX
		size_t rest = len;
		ssize_t curr;
		while (rest) {
			do {
				curr = read(fp->fd, (void*)((char*)buf + l), rest);
			} while (curr < 0 && EINTR == errno);
			if (curr < 0) return -1;
			if (curr == 0) break;
			l += curr; rest -= curr;
		}
	} else l = my_netread(fp->fd, buf, len);
	fp->offset += l;
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x4(%rax)
jne 0x6c2b3
movq $0x0, -0x8(%rbp)
jmp 0x6c3d6
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x6c2e4
movq -0x10(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x6c2e2
movq -0x10(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
jne 0x6c2d9
movq -0x10(%rbp), %rdi
callq 0x6b300
movq -0x10(%rbp), %rdi
callq 0x6b540
jmp 0x6c304
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x6c302
movq -0x10(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x6c300
movq -0x10(%rbp), %rdi
callq 0x6bb80
jmp 0x6c302
jmp 0x6c304
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x6c3a6
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x6c3a4
jmp 0x6c326
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x18(%rbp), %rsi
addq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x3230
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x39(%rbp)
jge 0x6c363
callq 0x35d0
movq %rax, %rcx
movl $0x4, %eax
cmpl (%rcx), %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x6c326
cmpq $0x0, -0x38(%rbp)
jge 0x6c37b
movq $-0x1, -0x8(%rbp)
jmp 0x6c3d6
cmpq $0x0, -0x38(%rbp)
jne 0x6c384
jmp 0x6c3a4
movq -0x38(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x6c319
jmp 0x6c3be
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6bf40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/htslib/cram/cram_codecs.c
// Function: cram_beta_decode_char
int cram_beta_decode_char(cram_slice *slice, cram_codec *c, cram_block *in, char *out, int *out_size) {
    int i, n;


    if (c->beta.nbits) {
        if (cram_not_enough_bits(in, c->beta.nbits))
            return -1;

	if (out)
	    for (i = 0, n = *out_size; i < n; i++)
		out[i] = get_bits_MSB(in, c->beta.nbits) - c->beta.offset;
	else
	    for (i = 0, n = *out_size; i < n; i++)
		get_bits_MSB(in, c->beta.nbits);
    } else {
	if (out)
	    for (i = 0, n = *out_size; i < n; i++)
		out[i] = -c->beta.offset;
    }

    return 0;
}

// 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)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x34(%rax)
je 0x6de32
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x34(%rax), %esi
callq 0x6d870
cmpl $0x0, %eax
je 0x6ddab
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6de7d
cmpq $0x0, -0x28(%rbp)
je 0x6ddfb
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x6ddf9
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x34(%rax), %esi
callq 0x6d900
movq -0x18(%rbp), %rcx
subl 0x30(%rcx), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6ddc2
jmp 0x6de30
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x6de2e
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x34(%rax), %esi
callq 0x6d900
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6de0b
jmp 0x6de30
jmp 0x6de76
cmpq $0x0, -0x28(%rbp)
je 0x6de74
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x6de72
movq -0x18(%rbp), %rcx
xorl %eax, %eax
subl 0x30(%rcx), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x6de49
jmp 0x6de74
jmp 0x6de76
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/htslib/cram/cram_codecs.c
// Function: cram_decoder_init
cram_codec *cram_decoder_init(enum cram_encoding codec,
			      char *data, int size,
			      enum cram_external_type option,
			      int version) {
    if (codec >= E_NULL && codec < E_NUM_CODECS && decode_init[codec]) {
	return decode_init[codec](data, size, option, version);
    } else {
	fprintf(stderr, "Unimplemented codec of type %s\n", cram_encoding2str(codec));
	return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpl $0x0, -0xc(%rbp)
jb 0x7199d
cmpl $0xa, -0xc(%rbp)
jae 0x7199d
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x13d2f(%rip), %rax     # 0x856a0
cmpq $0x0, (%rax,%rcx,8)
je 0x7199d
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x13d1c(%rip), %rax     # 0x856a0
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x719d0
movq 0x13644(%rip), %rax     # 0x84fe8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %edi
callq 0x74180
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x8f0f(%rip), %rsi      # 0x7a8d0
movb $0x0, %al
callq 0x37f0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhou-lab[P]tbmate/htslib/cram/cram_codecs.c
// Function: cram_encoder_init
cram_codec *cram_encoder_init(enum cram_encoding codec,
			      cram_stats *st,
			      enum cram_external_type option,
			      void *dat,
			      int version) {
    if (st && !st->nvals)
	return NULL;

    if (encode_init[codec]) {
	cram_codec *r;
	if ((r = encode_init[codec](st, option, dat, version)))
	    r->out = NULL;
	return r;
    } else {
	fprintf(stderr, "Unimplemented codec of type %s\n", cram_encoding2str(codec));
	abort();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7200b
movq -0x18(%rbp), %rax
cmpl $0x0, 0x100c(%rax)
jne 0x7200b
movq $0x0, -0x8(%rbp)
jmp 0x7208e
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x136d9(%rip), %rax     # 0x856f0
cmpq $0x0, (%rax,%rcx,8)
je 0x7205e
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x136c6(%rip), %rax     # 0x856f0
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq *%rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x72054
movq -0x38(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7208e
movq 0x12f83(%rip), %rax     # 0x84fe8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %edi
callq 0x74180
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x884e(%rip), %rsi      # 0x7a8d0
movb $0x0, %al
callq 0x37f0
callq 0x3100
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/bspwm.c
// Function: check_connection
bool check_connection (xcb_connection_t *dpy)
{
	int xerr;
	if ((xerr = xcb_connection_has_error(dpy)) != 0) {
		warn("The server closed the connection: ");
		switch (xerr) {
			case XCB_CONN_ERROR:
				warn("socket, pipe or stream error.\n");
				break;
			case XCB_CONN_CLOSED_EXT_NOTSUPPORTED:
				warn("unsupported extension.\n");
				break;
			case XCB_CONN_CLOSED_MEM_INSUFFICIENT:
				warn("not enough memory.\n");
				break;
			case XCB_CONN_CLOSED_REQ_LEN_EXCEED:
				warn("request length exceeded.\n");
				break;
			case XCB_CONN_CLOSED_PARSE_ERR:
				warn("can't parse display string.\n");
				break;
			case XCB_CONN_CLOSED_INVALID_SCREEN:
				warn("invalid screen.\n");
				break;
			case XCB_CONN_CLOSED_FDPASSING_FAILED:
				warn("failed to pass FD.\n");
				break;
			default:
				warn("unknown error.\n");
				break;
		}
		return false;
	} else {
		return true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4110
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x596b
leaq 0x279e5(%rip), %rdi     # 0x2d29d
xorl %eax, %eax
callq 0x6410
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x6, %eax
ja 0x5957
movq -0x20(%rbp), %rax
leaq 0x27776(%rip), %rcx     # 0x2d054
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x279d2(%rip), %rdi     # 0x2d2c0
movb $0x0, %al
callq 0x6410
jmp 0x5965
leaq 0x279e1(%rip), %rdi     # 0x2d2df
movb $0x0, %al
callq 0x6410
jmp 0x5965
leaq 0x279e9(%rip), %rdi     # 0x2d2f7
movb $0x0, %al
callq 0x6410
jmp 0x5965
leaq 0x279ed(%rip), %rdi     # 0x2d30b
movb $0x0, %al
callq 0x6410
jmp 0x5965
leaq 0x279f7(%rip), %rdi     # 0x2d325
movb $0x0, %al
callq 0x6410
jmp 0x5965
leaq 0x27a04(%rip), %rdi     # 0x2d342
movb $0x0, %al
callq 0x6410
jmp 0x5965
leaq 0x27a05(%rip), %rdi     # 0x2d353
movb $0x0, %al
callq 0x6410
jmp 0x5965
leaq 0x27a09(%rip), %rdi     # 0x2d367
movb $0x0, %al
callq 0x6410
movb $0x0, -0x1(%rbp)
jmp 0x596f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/bspwm.c
// Function: sig_handler
void sig_handler(int sig)
{
	if (sig == SIGCHLD) {
		signal(sig, sig_handler);
		while (waitpid(-1, 0, WNOHANG) > 0)
			;
	} else if (sig == SIGINT || sig == SIGHUP || sig == SIGTERM) {
		running = false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x11, -0x4(%rbp)
jne 0x613c
movl -0x4(%rbp), %edi
leaq -0x1b(%rip), %rsi       # 0x6100
callq 0x4070
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x4730
cmpl $0x0, %eax
jle 0x613a
jmp 0x6120
jmp 0x6157
cmpl $0x2, -0x4(%rbp)
je 0x614e
cmpl $0x1, -0x4(%rbp)
je 0x614e
cmpl $0xf, -0x4(%rbp)
jne 0x6155
movb $0x0, 0x2f56b(%rip)     # 0x356c0
jmp 0x6157
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/bspwm.c
// Function: cleanup
void cleanup(void)
{
	mon = NULL;

	while (mon_head != NULL) {
		remove_monitor(mon_head);
	}
	while (rule_head != NULL) {
		remove_rule(rule_head);
	}
	while (subscribe_head != NULL) {
		remove_subscriber(subscribe_head);
	}
	while (pending_rule_head != NULL) {
		remove_pending_rule(pending_rule_head);
	}

	empty_history();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x0, 0x2f591(%rip) # 0x35700
cmpq $0x0, 0x2f581(%rip)     # 0x356f8
je 0x6187
movq 0x2f578(%rip), %rdi     # 0x356f8
callq 0x8e00
jmp 0x616f
jmp 0x6189
cmpq $0x0, 0x2f597(%rip)     # 0x35728
je 0x61a1
movq 0x2f58e(%rip), %rdi     # 0x35728
callq 0x29650
jmp 0x6189
jmp 0x61a3
cmpq $0x0, 0x2f59d(%rip)     # 0x35748
je 0x61bb
movq 0x2f594(%rip), %rdi     # 0x35748
callq 0x2bbc0
jmp 0x61a3
jmp 0x61bd
cmpq $0x0, 0x2f503(%rip)     # 0x356c8
je 0x61d5
movq 0x2f4fa(%rip), %rdi     # 0x356c8
callq 0x29a70
jmp 0x61bd
callq 0x12930
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/bspwm.c
// Function: init
void init(void)
{
	clients_count = 0;
	mon = mon_head = mon_tail = pri_mon = NULL;
	history_head = history_tail = history_needle = NULL;
	rule_head = rule_tail = NULL;
	stack_head = stack_tail = NULL;
	subscribe_head = subscribe_tail = NULL;
	pending_rule_head = pending_rule_tail = NULL;
	auto_raise = sticky_still = hide_sticky = record_history = true;
	randr_base = 0;
	exit_status = 0;
	restart = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x2f4c6(%rip)     # 0x356e4
movq $0x0, 0x2f4bf(%rip) # 0x356e8
movq $0x0, 0x2f4bc(%rip) # 0x356f0
movq $0x0, 0x2f4b9(%rip) # 0x356f8
movq $0x0, 0x2f4b6(%rip) # 0x35700
movq $0x0, 0x2f4b3(%rip) # 0x35708
movq $0x0, 0x2f4b0(%rip) # 0x35710
movq $0x0, 0x2f4ad(%rip) # 0x35718
movq $0x0, 0x2f4aa(%rip) # 0x35720
movq $0x0, 0x2f4a7(%rip) # 0x35728
movq $0x0, 0x2f4a4(%rip) # 0x35730
movq $0x0, 0x2f4a1(%rip) # 0x35738
movq $0x0, 0x2f49e(%rip) # 0x35740
movq $0x0, 0x2f49b(%rip) # 0x35748
movq $0x0, 0x2f498(%rip) # 0x35750
movq $0x0, 0x2f405(%rip) # 0x356c8
movb $0x1, 0x2f48e(%rip)     # 0x35758
movb $0x1, 0x2f488(%rip)     # 0x35759
movb $0x1, 0x2f482(%rip)     # 0x3575a
movb $0x1, 0x2f47c(%rip)     # 0x3575b
leaq 0x2fb1a(%rip), %rax     # 0x35e00
movb $0x0, (%rax)
movl $0x0, 0x2f3ed(%rip)     # 0x356e0
movb $0x0, 0x2f3d6(%rip)     # 0x356d0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/bspwm.c
// Function: register_events
void register_events(void)
{
	uint32_t values[] = {ROOT_EVENT_MASK};
	xcb_generic_error_t *e = xcb_request_check(dpy, xcb_change_window_attributes_checked(dpy, root, XCB_CW_EVENT_MASK, values));
	if (e != NULL) {
		free(e);
		xcb_ewmh_connection_wipe(ewmh);
		free(ewmh);
		xcb_disconnect(dpy);
		err("Another window manager is already running.\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x2707a(%rip), %eax     # 0x2d388
movl %eax, -0x4(%rbp)
movq 0x2f3a0(%rip), %rax     # 0x356b8
movq %rax, -0x20(%rbp)
movq 0x2f395(%rip), %rdi     # 0x356b8
movl 0x2f43f(%rip), %esi     # 0x35768
leaq -0x4(%rbp), %rcx
movl $0x800, %edx            # imm = 0x800
callq 0x4630
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x48e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6392
movq -0x10(%rbp), %rdi
callq 0x4450
leaq 0x2fabf(%rip), %rax     # 0x35e20
movq (%rax), %rdi
callq 0x61e0
leaq 0x2fab0(%rip), %rax     # 0x35e20
movq (%rax), %rdi
callq 0x4450
movq 0x2f339(%rip), %rdi     # 0x356b8
callq 0x4960
leaq 0x26ee6(%rip), %rdi     # 0x2d271
movb $0x0, %al
callq 0x64b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/geometry.c
// Function: boundary_distance
uint32_t boundary_distance(xcb_rectangle_t r1, xcb_rectangle_t r2, direction_t dir)
{
	xcb_point_t r1_max = {r1.x + r1.width - 1, r1.y + r1.height - 1};
	xcb_point_t r2_max = {r2.x + r2.width - 1, r2.y + r2.height - 1};
	switch (dir) {
		case DIR_NORTH:
			return r2_max.y > r1.y ? r2_max.y - r1.y : r1.y - r2_max.y;
			break;
		case DIR_WEST:
			return r2_max.x > r1.x ? r2_max.x - r1.x : r1.x - r2_max.x;
			break;
		case DIR_SOUTH:
			return r2.y < r1_max.y ? r1_max.y - r2.y : r2.y - r1_max.y;
			break;
		case DIR_EAST:
			return r2.x < r1_max.x ? r1_max.x - r2.x : r2.x - r1_max.x;
			break;
		default:
			return UINT32_MAX;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0xc(%rbp)
movq %rsi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movzwl -0xc(%rbp), %edx
movzwl -0x8(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal -0x1(%rax,%rcx), %eax
movw %ax, -0x1c(%rbp)
movzwl -0xa(%rbp), %edx
movzwl -0x6(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal -0x1(%rax,%rcx), %eax
movw %ax, -0x1a(%rbp)
movzwl -0x14(%rbp), %edx
movzwl -0x10(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal -0x1(%rax,%rcx), %eax
movw %ax, -0x20(%rbp)
movzwl -0x12(%rbp), %edx
movzwl -0xe(%rbp), %eax
movl %eax, %ecx
movl %edx, %eax
leal -0x1(%rax,%rcx), %eax
movw %ax, -0x1e(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x3, %rax
ja 0x6e37
movq -0x28(%rbp), %rax
leaq 0x26695(%rip), %rcx     # 0x2d400
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movswl -0x1e(%rbp), %eax
movswl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jle 0x6d8f
movswl -0x1e(%rbp), %eax
movswl -0xa(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6d9c
movswl -0xa(%rbp), %eax
movswl -0x1e(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6e3e
movswl -0x20(%rbp), %eax
movswl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jle 0x6dc2
movswl -0x20(%rbp), %eax
movswl -0xc(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x30(%rbp)
jmp 0x6dcf
movswl -0xc(%rbp), %eax
movswl -0x20(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6e3e
movswl -0x12(%rbp), %eax
movswl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jge 0x6df2
movswl -0x1a(%rbp), %eax
movswl -0x12(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x34(%rbp)
jmp 0x6dff
movswl -0x12(%rbp), %eax
movswl -0x1a(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6e3e
movswl -0x14(%rbp), %eax
movswl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x6e22
movswl -0x1c(%rbp), %eax
movswl -0x14(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x38(%rbp)
jmp 0x6e2f
movswl -0x14(%rbp), %eax
movswl -0x1c(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6e3e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/geometry.c
// Function: rect_cmp
int rect_cmp(xcb_rectangle_t r1, xcb_rectangle_t r2)
{
	if (r1.y >= (r2.y + r2.height)) {
		return 1;
	} else if (r2.y >= (r1.y + r1.height)) {
		return -1;
	} else {
		if (r1.x >= (r2.x + r2.width)) {
			return 1;
		} else if (r2.x >= (r1.x + r1.width)) {
			return -1;
		} else {
			return area(r2) - area(r1);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0xc(%rbp)
movq %rsi, -0x14(%rbp)
movswl -0xa(%rbp), %eax
movswl -0x12(%rbp), %ecx
movzwl -0xe(%rbp), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jl 0x718b
movl $0x1, -0x4(%rbp)
jmp 0x71fb
movswl -0x12(%rbp), %eax
movswl -0xa(%rbp), %ecx
movzwl -0x6(%rbp), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jl 0x71a6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x71fb
movswl -0xc(%rbp), %eax
movswl -0x14(%rbp), %ecx
movzwl -0x10(%rbp), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jl 0x71c1
movl $0x1, -0x4(%rbp)
jmp 0x71fb
movswl -0x14(%rbp), %eax
movswl -0xc(%rbp), %ecx
movzwl -0x8(%rbp), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jl 0x71dc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x71fb
movq -0x14(%rbp), %rdi
callq 0x6cd0
movl %eax, -0x18(%rbp)
movq -0xc(%rbp), %rdi
callq 0x6cd0
movl %eax, %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/jsmn.c
// Function: jsmn_alloc_token
static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser,
		jsmntok_t *tokens, size_t num_tokens) {
	jsmntok_t *tok;
	if (parser->toknext >= num_tokens) {
		return NULL;
	}
	tok = &tokens[parser->toknext++];
	tok->start = tok->end = -1;
	tok->size = 0;
#ifdef JSMN_PARENT_LINKS
	tok->parent = -1;
#endif
	return tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cmpq -0x20(%rbp), %rax
jb 0x7717
movq $0x0, -0x8(%rbp)
jmp 0x7760
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x4(%rdx)
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/jsmn.c
// Function: jsmn_fill_token
static void jsmn_fill_token(jsmntok_t *token, jsmntype_t type,
                            int start, int end) {
	token->type = type;
	token->start = start;
	token->end = end;
	token->size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/settings.c
// Function: run_config
void run_config(int run_level)
{
	if (fork() == 0) {
		if (dpy != NULL) {
			close(xcb_get_file_descriptor(dpy));
		}
		setsid();
		char arg1[2];
		snprintf(arg1, 2, "%i", run_level);
		execl(config_path, config_path, arg1, (char *) NULL);
		err("Couldn't execute the configuration file.\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x4990
cmpl $0x0, %eax
jne 0x7c6e
leaq 0x2daac(%rip), %rax     # 0x356b8
cmpq $0x0, (%rax)
je 0x7c28
leaq 0x2da9f(%rip), %rax     # 0x356b8
movq (%rax), %rdi
callq 0x4390
movl %eax, %edi
callq 0x4160
callq 0x4130
leaq -0x6(%rbp), %rdi
movl -0x4(%rbp), %ecx
movl $0x2, %esi
leaq 0x27699(%rip), %rdx     # 0x2f2d9
movb $0x0, %al
callq 0x4120
leaq -0x6(%rbp), %rdx
leaq 0x2d95e(%rip), %rsi     # 0x355b0
xorl %eax, %eax
movl %eax, %ecx
movq %rsi, %rdi
movb $0x0, %al
callq 0x4240
leaq 0x25931(%rip), %rdi     # 0x2d598
movb $0x0, %al
callq 0x64b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/monitor.c
// Function: make_monitor
monitor_t *make_monitor(const char *name, xcb_rectangle_t *rect, uint32_t id)
{
	monitor_t *m = calloc(1, sizeof(monitor_t));
	if (id == XCB_NONE) {
		m->id = xcb_generate_id(dpy);
	}
	m->randr_id = XCB_NONE;
	snprintf(m->name, sizeof(m->name), "%s", name == NULL ? DEFAULT_MON_NAME : name);
	m->padding = padding;
	m->border_width = border_width;
	m->window_gap = window_gap;
	m->root = XCB_NONE;
	m->prev = m->next = NULL;
	m->desk = m->desk_head = m->desk_tail = NULL;
	m->wired = true;
	m->sticky_count = 0;
	if (rect != NULL) {
		update_root(m, rect);
	} else {
		m->rectangle = (xcb_rectangle_t) {0, 0, screen_width, screen_height};
	}
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, %edi
movl $0x80, %esi
callq 0x4890
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x0, %rax
jne 0x7f07
leaq 0x2d7c2(%rip), %rax     # 0x356b8
movq (%rax), %rdi
callq 0x4900
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7f2e
leaq 0x256ba(%rip), %rax     # 0x2d5e2
movq %rax, -0x38(%rbp)
jmp 0x7f36
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rcx
movl $0x20, %esi
leaq 0x251a6(%rip), %rdx     # 0x2d0f0
movb $0x0, %al
callq 0x4120
movq -0x20(%rbp), %rax
leaq 0x2de34(%rip), %rcx     # 0x35d90
movq (%rcx), %rdx
movq %rdx, 0x30(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x38(%rax)
leaq 0x2de42(%rip), %rax     # 0x35db4
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x48(%rax)
leaq 0x2de2e(%rip), %rax     # 0x35db0
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x44(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x78(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x2c(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x40(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x7ffb
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8040
jmp 0x802d
movq -0x20(%rbp), %rax
movw $0x0, -0x28(%rbp)
movw $0x0, -0x26(%rbp)
leaq 0x2d75a(%rip), %rcx     # 0x3576c
movl (%rcx), %ecx
movw %cx, -0x24(%rbp)
leaq 0x2d751(%rip), %rcx     # 0x35770
movl (%rcx), %ecx
movw %cx, -0x22(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, 0x4c(%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/monitor.c
// Function: reorder_monitor
void reorder_monitor(monitor_t *m)
{
	if (m == NULL) {
		return;
	}
	monitor_t *prev = m->prev;
	while (prev != NULL && rect_cmp(m->rectangle, prev->rectangle) < 0) {
		swap_monitors(m, prev);
		prev = m->prev;
	}
	monitor_t *next = m->next;
	while (next != NULL && rect_cmp(m->rectangle, next->rectangle) > 0) {
		swap_monitors(m, next);
		next = m->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8648
jmp 0x86fc
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x867e
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x4c(%rcx), %rdi
movq 0x4c(%rax), %rsi
callq 0x7160
cmpl $0x0, %eax
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x8687
jmp 0x86a2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8710
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x8654
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1a(%rbp)
je 0x86d8
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x4c(%rcx), %rdi
movq 0x4c(%rax), %rsi
callq 0x7160
cmpl $0x0, %eax
setg %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x86e1
jmp 0x86fc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8710
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x86ae
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/monitor.c
// Function: rename_monitor
void rename_monitor(monitor_t *m, const char *name)
{
	put_status(SBSC_MASK_MONITOR_RENAME, "monitor_rename 0x%08X %s %s\n", m->id, m->name, name);

	snprintf(m->name, sizeof(m->name), "%s", name);
	xcb_icccm_set_wm_name(dpy, m->root, XCB_ATOM_STRING, 8, strlen(m->name), m->name);

	put_status(SBSC_MASK_REPORT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
movl $0x4, %edi
leaq 0x24c84(%rip), %rsi     # 0x2d60f
movb $0x0, %al
callq 0x2c0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x20, %esi
leaq 0x2474a(%rip), %rdx     # 0x2d0f0
movb $0x0, %al
callq 0x4120
leaq 0x2cd04(%rip), %rax     # 0x356b8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4460
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movl %eax, %r8d
movq -0x8(%rbp), %r9
movl $0x1f, %edx
movl $0x8, %ecx
callq 0x4190
movl %eax, -0x14(%rbp)
movl $0x1, %edi
movb $0x0, %al
callq 0x2c0b0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/monitor.c
// Function: find_monitor
monitor_t *find_monitor(uint32_t id)
{
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		if (m->id == id) {
			return m;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
leaq 0x2ccea(%rip), %rax     # 0x356f8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8a42
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x8a32
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8a4a
jmp 0x8a34
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x8a15
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/monitor.c
// Function: get_monitor_by_randr_id
monitor_t *get_monitor_by_randr_id(xcb_randr_output_t id)
{
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		if (m->randr_id == id) {
			return m;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
leaq 0x2cc9a(%rip), %rax     # 0x356f8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8a92
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x8a82
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8a9a
jmp 0x8a84
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x8a65
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/monitor.c
// Function: embrace_client
void embrace_client(monitor_t *m, client_t *c)
{
	if ((c->floating_rectangle.x + c->floating_rectangle.width) <= m->rectangle.x) {
		c->floating_rectangle.x = m->rectangle.x;
	} else if (c->floating_rectangle.x >= (m->rectangle.x + m->rectangle.width)) {
		c->floating_rectangle.x = (m->rectangle.x + m->rectangle.width) - c->floating_rectangle.width;
	}
	if ((c->floating_rectangle.y + c->floating_rectangle.height) <= m->rectangle.y) {
		c->floating_rectangle.y = m->rectangle.y;
	} else if (c->floating_rectangle.y >= (m->rectangle.y + m->rectangle.height)) {
		c->floating_rectangle.y = (m->rectangle.y + m->rectangle.height) - c->floating_rectangle.height;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x318(%rax), %eax
movq -0x10(%rbp), %rcx
movzwl 0x31c(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movswl 0x4c(%rcx), %ecx
cmpl %ecx, %eax
jg 0x8ae5
movq -0x8(%rbp), %rax
movw 0x4c(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x318(%rax)
jmp 0x8b35
movq -0x10(%rbp), %rax
movswl 0x318(%rax), %eax
movq -0x8(%rbp), %rcx
movswl 0x4c(%rcx), %ecx
movq -0x8(%rbp), %rdx
movzwl 0x50(%rdx), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jl 0x8b33
movq -0x8(%rbp), %rax
movswl 0x4c(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x50(%rcx), %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movzwl 0x31c(%rcx), %ecx
subl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x318(%rax)
jmp 0x8b35
movq -0x10(%rbp), %rax
movswl 0x31a(%rax), %eax
movq -0x10(%rbp), %rcx
movzwl 0x31e(%rcx), %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movswl 0x4e(%rcx), %ecx
cmpl %ecx, %eax
jg 0x8b6e
movq -0x8(%rbp), %rax
movw 0x4e(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x31a(%rax)
jmp 0x8bbe
movq -0x10(%rbp), %rax
movswl 0x31a(%rax), %eax
movq -0x8(%rbp), %rcx
movswl 0x4e(%rcx), %ecx
movq -0x8(%rbp), %rdx
movzwl 0x52(%rdx), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jl 0x8bbc
movq -0x8(%rbp), %rax
movswl 0x4e(%rax), %eax
movq -0x8(%rbp), %rcx
movzwl 0x52(%rcx), %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movzwl 0x31e(%rcx), %ecx
subl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x31a(%rax)
jmp 0x8bbe
popq %rbp
retq